nautobot 2.2.0b1__py3-none-any.whl → 2.2.2__py3-none-any.whl

nautobot/dcim/tests/test_api.py

@@ -26,7 +26,7 @@ from nautobot.dcim.models import (
     ConsoleServerPort,
     ConsoleServerPortTemplate,
     Controller,
-    ControllerDeviceGroup,
+    ControllerManagedDeviceGroup,
     Device,
     DeviceBay,
     DeviceBayTemplate,
@@ -618,6 +618,42 @@ class RackTest(APIViewTestCases.APIViewTestCase):
         self.assertEqual(response.get("Content-Type"), "image/svg+xml")
         self.assertIn(b'class="slot" height="19" width="190"', response.content)
 
+    @override_settings(
+        RACK_ELEVATION_UNIT_TWO_DIGIT_FORMAT=False,
+        RACK_ELEVATION_DEFAULT_UNIT_HEIGHT=22,
+        RACK_ELEVATION_DEFAULT_UNIT_WIDTH=230,
+    )
+    @override_config(RACK_ELEVATION_UNIT_TWO_DIGIT_FORMAT=True)
+    def test_get_rack_elevation_unit_svg_settings_overridden(self):
+        """
+        GET a single rack elevation in SVG format, with Django settings specifying the default RU display format
+        """
+        rack = Rack.objects.first()
+        self.add_permissions("dcim.view_rack")
+        reverse_url = reverse("dcim-api:rack-elevation", kwargs={"pk": rack.pk})
+        url = f"{reverse_url}?render=svg"
+
+        response = self.client.get(url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertEqual(response.get("Content-Type"), "image/svg+xml")
+        self.assertIn(b'<text class="unit" x="15.0" y="915.0">1</text>', response.content)
+
+    @override_settings(RACK_ELEVATION_DEFAULT_UNIT_HEIGHT=22, RACK_ELEVATION_DEFAULT_UNIT_WIDTH=230)
+    @override_config(RACK_ELEVATION_UNIT_TWO_DIGIT_FORMAT=True)
+    def test_get_rack_elevation_unit_svg_config_overridden(self):
+        """
+        GET a single rack elevation in SVG format, with Constance config specifying the 2-digit RU display format
+        """
+        rack = Rack.objects.first()
+        self.add_permissions("dcim.view_rack")
+        reverse_url = reverse("dcim-api:rack-elevation", kwargs={"pk": rack.pk})
+        url = f"{reverse_url}?render=svg"
+
+        response = self.client.get(url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertEqual(response.get("Content-Type"), "image/svg+xml")
+        self.assertIn(b'<text class="unit" x="15.0" y="915.0">01</text>', response.content)
+
     def test_detail_view_schema(self):
         url = self._get_detail_url(self._get_queryset().first())
         response = self.client.options(url, **self.header)
@@ -771,6 +807,7 @@ class ManufacturerTest(APIViewTestCases.APIViewTestCase):
         # FIXME: This has to be replaced with# `get_deletable_object` and
         # `get_deletable_object_pks` but this is a workaround just so all of these objects are
         # deletable for now.
+        Controller.objects.filter(controller_device__isnull=False).delete()
         Device.objects.all().delete()
         DeviceType.objects.all().delete()
         Platform.objects.all().delete()
@@ -1166,6 +1203,7 @@ class DeviceTest(APIViewTestCases.APIViewTestCase):
 
     @classmethod
     def setUpTestData(cls):
+        Controller.objects.filter(controller_device__isnull=False).delete()
         Device.objects.all().delete()
         locations = Location.objects.filter(location_type=LocationType.objects.get(name="Campus"))[:2]
 
@@ -2168,7 +2206,10 @@ class ConnectedDeviceTest(APITestCase):
     def test_get_connected_device(self):
         url = reverse("dcim-api:connected-device-list")
         response = self.client.get(url + "?peer_device=TestDevice2&peer_interface=eth0", **self.header)
+        self.assertHttpStatus(response, status.HTTP_404_NOT_FOUND)
 
+        self.add_permissions("dcim.view_interface")
+        response = self.client.get(url + "?peer_device=TestDevice2&peer_interface=eth0", **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertEqual(response.data["name"], self.device1.name)
 
@@ -2813,8 +2854,8 @@ class ControllerTestCase(APIViewTestCases.APIViewTestCase):
         }
 
 
-class ControllerDeviceGroupTestCase(APIViewTestCases.APIViewTestCase):
-    model = ControllerDeviceGroup
+class ControllerManagedDeviceGroupTestCase(APIViewTestCases.APIViewTestCase):
+    model = ControllerManagedDeviceGroup
 
     @classmethod
     def setUpTestData(cls):
@@ -2822,17 +2863,17 @@ class ControllerDeviceGroupTestCase(APIViewTestCases.APIViewTestCase):
 
         cls.create_data = [
             {
-                "name": "ControllerDeviceGroup 1",
+                "name": "ControllerManagedDeviceGroup 1",
                 "controller": controllers[0].pk,
                 "weight": 100,
             },
             {
-                "name": "ControllerDeviceGroup 2",
+                "name": "ControllerManagedDeviceGroup 2",
                 "controller": controllers[1].pk,
                 "weight": 150,
             },
             {
-                "name": "ControllerDeviceGroup 3",
+                "name": "ControllerManagedDeviceGroup 3",
                 "controller": controllers[2].pk,
                 "weight": 200,
             },

nautobot/dcim/tests/test_filters.py

@@ -26,8 +26,8 @@ from nautobot.dcim.filters import (
     ConsolePortTemplateFilterSet,
     ConsoleServerPortFilterSet,
     ConsoleServerPortTemplateFilterSet,
-    ControllerDeviceGroupFilterSet,
     ControllerFilterSet,
+    ControllerManagedDeviceGroupFilterSet,
     DeviceBayFilterSet,
     DeviceBayTemplateFilterSet,
     DeviceFamilyFilterSet,
@@ -68,7 +68,7 @@ from nautobot.dcim.models import (
     ConsoleServerPort,
     ConsoleServerPortTemplate,
     Controller,
-    ControllerDeviceGroup,
+    ControllerManagedDeviceGroup,
     Device,
     DeviceBay,
     DeviceBayTemplate,
@@ -112,6 +112,7 @@ User = get_user_model()
 
 
 def common_test_data(cls):
+    Controller.objects.filter(controller_device__isnull=False).delete()
     Device.objects.all().delete()
     tenants = Tenant.objects.filter(tenant_group__isnull=False)
     cls.tenants = tenants
@@ -619,6 +620,82 @@ def common_test_data(cls):
     cls.devices[0].tags.set(Tag.objects.get_for_model(Device))
     cls.devices[1].tags.set(Tag.objects.get_for_model(Device)[:3])
 
+    controller_statuses = iter(Status.objects.get_for_model(Controller))
+    external_integrations = iter(ExternalIntegration.objects.all())
+    device_redundancy_groups = iter(DeviceRedundancyGroup.objects.all())
+
+    cls.controllers = (
+        Controller.objects.create(
+            name="Controller 1",
+            status=next(controller_statuses),
+            description="First",
+            location=loc0,
+            platform=platforms[0],
+            role=cls.device_roles[0],
+            tenant=tenants[0],
+            external_integration=next(external_integrations),
+            controller_device=cls.devices[0],
+        ),
+        Controller.objects.create(
+            name="Controller 2",
+            status=next(controller_statuses),
+            description="Second",
+            location=loc1,
+            platform=platforms[1],
+            role=cls.device_roles[1],
+            tenant=tenants[1],
+            external_integration=next(external_integrations),
+            controller_device=cls.devices[1],
+        ),
+        Controller.objects.create(
+            name="Controller 3",
+            status=next(controller_statuses),
+            description="Third",
+            location=loc2,
+            platform=platforms[2],
+            role=cls.device_roles[2],
+            tenant=tenants[2],
+            external_integration=next(external_integrations),
+            controller_device_redundancy_group=next(device_redundancy_groups),
+        ),
+        Controller.objects.create(
+            name="Controller 4",
+            status=next(controller_statuses),
+            description="Forth",
+            location=loc2,
+            platform=platforms[2],
+            role=cls.device_roles[2],
+            tenant=tenants[2],
+            external_integration=next(external_integrations),
+            controller_device_redundancy_group=next(device_redundancy_groups),
+        ),
+    )
+    cls.controllers[0].tags.set(Tag.objects.get_for_model(Controller))
+    cls.controllers[1].tags.set(Tag.objects.get_for_model(Controller)[:3])
+
+    parent_controller_managed_device_group = ControllerManagedDeviceGroup.objects.create(
+        name="Managed Device Group 11",
+        weight=1000,
+        controller=cls.controllers[0],
+    )
+    cls.controller_managed_device_groups = (
+        parent_controller_managed_device_group,
+        ControllerManagedDeviceGroup.objects.create(
+            name="Managed Device Group 12",
+            weight=2000,
+            controller=cls.controllers[1],
+            parent=parent_controller_managed_device_group,
+        ),
+        ControllerManagedDeviceGroup.objects.create(
+            name="Managed Device Group 13",
+            weight=3000,
+            controller=cls.controllers[2],
+            parent=parent_controller_managed_device_group,
+        ),
+    )
+    parent_controller_managed_device_group.tags.set(Tag.objects.get_for_model(ControllerManagedDeviceGroup))
+    cls.controller_managed_device_groups[1].tags.set(Tag.objects.get_for_model(ControllerManagedDeviceGroup)[:3])
+
 
 class LocationTypeFilterSetTestCase(FilterTestCases.NameOnlyFilterTestCase):
     queryset = LocationType.objects.all()
@@ -1341,8 +1418,8 @@ class DeviceTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilt
         ("device_redundancy_group", "device_redundancy_group__id"),
         ("device_redundancy_group", "device_redundancy_group__name"),
         ("device_redundancy_group_priority",),
-        ("controller_device_group", "controller_device_group__id"),
-        ("controller_device_group", "controller_device_group__name"),
+        ("controller_managed_device_group", "controller_managed_device_group__id"),
+        ("controller_managed_device_group", "controller_managed_device_group__name"),
         ("device_type", "device_type__id"),
         ("device_type", "device_type__model"),
         ("front_ports", "front_ports__id"),
@@ -1415,19 +1492,19 @@ class DeviceTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilt
         Service.objects.create(device=devices[0], name="ssh", protocol="tcp", ports=[22])
         Service.objects.create(device=devices[1], name="dns", protocol="udp", ports=[53])
 
-        cls.controller_device_groups = list(ControllerDeviceGroup.objects.all()[:2])
+        cls.controller_managed_device_groups = list(ControllerManagedDeviceGroup.objects.all()[:2])
         cls.device_redundancy_groups = list(DeviceRedundancyGroup.objects.all()[:2])
         Device.objects.filter(pk=devices[0].pk).update(
-            controller_device_group=cls.controller_device_groups[0],
+            controller_managed_device_group=cls.controller_managed_device_groups[0],
             device_redundancy_group=cls.device_redundancy_groups[0],
         )
         Device.objects.filter(pk=devices[1].pk).update(
-            controller_device_group=cls.controller_device_groups[0],
+            controller_managed_device_group=cls.controller_managed_device_groups[0],
             device_redundancy_group=cls.device_redundancy_groups[0],
             device_redundancy_group_priority=1,
         )
         Device.objects.filter(pk=devices[2].pk).update(
-            controller_device_group=cls.controller_device_groups[1],
+            controller_managed_device_group=cls.controller_managed_device_groups[1],
             device_redundancy_group=cls.device_redundancy_groups[1],
             device_redundancy_group_priority=100,
         )
@@ -3355,63 +3432,20 @@ class ControllerFilterSetTestCase(FilterTestCases.FilterTestCase):
         ("platform", "platform__name"),
         ("external_integration", "external_integration__id"),
         ("external_integration", "external_integration__name"),
-        ("deployed_controller_device", "deployed_controller_device__id"),
-        ("deployed_controller_device", "deployed_controller_device__name"),
-        ("deployed_controller_group", "deployed_controller_group__id"),
-        ("deployed_controller_group", "deployed_controller_group__name"),
+        ("controller_device", "controller_device__id"),
+        ("controller_device", "controller_device__name"),
+        ("controller_device_redundancy_group", "controller_device_redundancy_group__id"),
+        ("controller_device_redundancy_group", "controller_device_redundancy_group__name"),
     )
 
     @classmethod
     def setUpTestData(cls):
         common_test_data(cls)
 
-        external_integrations = iter(ExternalIntegration.objects.all())
-        locations = iter(Location.objects.filter(location_type__name="Campus"))
-        platforms = iter(Platform.objects.all())
-        roles = iter(Role.objects.get_for_model(Controller))
-        statuses = iter(Status.objects.get_for_model(Controller))
-        tenants = iter(Tenant.objects.all())
-
-        cls.controllers = (
-            Controller.objects.create(
-                name="Controller 1",
-                status=next(statuses),
-                description="First",
-                location=next(locations),
-                platform=next(platforms),
-                role=next(roles),
-                tenant=next(tenants),
-                external_integration=next(external_integrations),
-                deployed_controller_device=cls.devices[0],
-            ),
-            Controller.objects.create(
-                name="Controller 2",
-                status=next(statuses),
-                description="Second",
-                location=next(locations),
-                platform=next(platforms),
-                role=next(roles),
-                tenant=next(tenants),
-                external_integration=next(external_integrations),
-                deployed_controller_device=cls.devices[1],
-            ),
-            Controller.objects.create(
-                name="Controller 3",
-                status=next(statuses),
-                description="Third",
-                location=next(locations),
-                platform=next(platforms),
-                role=next(roles),
-                tenant=next(tenants),
-                external_integration=next(external_integrations),
-                deployed_controller_group=DeviceRedundancyGroup.objects.first(),
-            ),
-        )
-
 
-class ControllerDeviceGroupFilterSetTestCase(FilterTestCases.FilterTestCase):
-    queryset = ControllerDeviceGroup.objects.all()
-    filterset = ControllerDeviceGroupFilterSet
+class ControllerManagedDeviceGroupFilterSetTestCase(FilterTestCases.FilterTestCase):
+    queryset = ControllerManagedDeviceGroup.objects.all()
+    filterset = ControllerManagedDeviceGroupFilterSet
     generic_filter_tests = (
         ("name",),
         ("weight",),
@@ -3424,26 +3458,3 @@ class ControllerDeviceGroupFilterSetTestCase(FilterTestCases.FilterTestCase):
     @classmethod
     def setUpTestData(cls):
         common_test_data(cls)
-
-        cls.controllers = Controller.objects.all()[:3]
-
-        group1 = ControllerDeviceGroup.objects.create(
-            name="Controller Device Group 11",
-            weight=1000,
-            controller=cls.controllers[0],
-        )
-        cls.controller_device_groups = (
-            group1,
-            ControllerDeviceGroup.objects.create(
-                name="Controller Device Group 12",
-                weight=2000,
-                controller=cls.controllers[1],
-                parent=group1,
-            ),
-            ControllerDeviceGroup.objects.create(
-                name="Controller Device Group 13",
-                weight=3000,
-                controller=cls.controllers[2],
-                parent=group1,
-            ),
-        )

nautobot/dcim/tests/test_forms.py

@@ -1,8 +1,8 @@
 from django.test import TestCase
 
 from nautobot.core.testing.forms import FormTestCases
-from nautobot.dcim.choices import DeviceFaceChoices, InterfaceTypeChoices, RackWidthChoices
-from nautobot.dcim.forms import DeviceFilterForm, DeviceForm, InterfaceCreateForm, RackForm
+from nautobot.dcim.choices import DeviceFaceChoices, InterfaceModeChoices, InterfaceTypeChoices, RackWidthChoices
+from nautobot.dcim.forms import DeviceFilterForm, DeviceForm, InterfaceCreateForm, InterfaceForm, RackForm
 from nautobot.dcim.models import (
     Device,
     DeviceType,
@@ -14,6 +14,7 @@ from nautobot.dcim.models import (
     Rack,
 )
 from nautobot.extras.models import Role, SecretsGroup, Status
+from nautobot.ipam.models import VLAN
 from nautobot.tenancy.models import Tenant
 from nautobot.virtualization.models import Cluster, ClusterGroup, ClusterType
 
@@ -263,3 +264,49 @@ class RackTestCase(TestCase):
         }
         form = RackForm(data=data, instance=racks[0])
         self.assertTrue(form.is_valid())
+
+
+class InterfaceTestCase(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.device = Device.objects.first()
+        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,
+        )
+        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,
+            "mode": InterfaceModeChoices.MODE_TAGGED,
+            "tagged_vlans": [cls.vlan.pk],
+        }
+
+    def test_interface_form_clean_vlan_location_fail(self):
+        """Assert that form validation fails when no matching locations are associated to tagged VLAN"""
+        self.vlan.locations.set(list(Location.objects.exclude(pk=self.device.location.pk))[:2])
+        form = InterfaceForm(data=self.data, instance=self.interface)
+        self.assertFalse(form.is_valid())
+
+    def test_interface_vlan_location_clean_multiple_locations_pass(self):
+        """Assert that form validation passes when multiple locations are associated to tagged VLAN with one matching"""
+        self.vlan.locations.add(self.device.location)
+        form = InterfaceForm(data=self.data, instance=self.interface)
+        self.assertTrue(form.is_valid())
+
+    def test_interface_vlan_location_clean_single_location_pass(self):
+        """Assert that form validation passes when a single location is associated to tagged VLAN"""
+        self.vlan.locations.set([self.device.location])
+        form = InterfaceForm(data=self.data, instance=self.interface)
+        self.assertTrue(form.is_valid())
+
+    def test_interface_vlan_location_clean_no_locations_pass(self):
+        """Assert that form validation passes when no locations are associated to tagged VLAN"""
+        self.vlan.locations.clear()
+        form = InterfaceForm(data=self.data, instance=self.interface)
+        self.assertTrue(form.is_valid())

nautobot/dcim/tests/test_graphql.py

@@ -4,12 +4,22 @@ 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.models import Device, DeviceType, Interface, Location, LocationType, Manufacturer, Platform
+from nautobot.dcim.models import (
+    Controller,
+    Device,
+    DeviceType,
+    Interface,
+    Location,
+    LocationType,
+    Manufacturer,
+    Platform,
+)
 from nautobot.extras.models import DynamicGroup, Role, Status
 
 
 class GraphQLTestCase(TestCase):
     def setUp(self):
+        Controller.objects.filter(controller_device__isnull=False).delete()
         Device.objects.all().delete()
         self.user = create_test_user("graphql_testuser")
         self.location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()

nautobot/dcim/tests/test_models.py

@@ -24,7 +24,7 @@ from nautobot.dcim.models import (
     ConsoleServerPort,
     ConsoleServerPortTemplate,
     Controller,
-    ControllerDeviceGroup,
+    ControllerManagedDeviceGroup,
     Device,
     DeviceBay,
     DeviceBayTemplate,
@@ -1896,13 +1896,13 @@ class ControllerTestCase(ModelTestCases.BaseModelTestCase):
             status=Status.objects.get_for_model(Controller).first(),
             role=Role.objects.get_for_model(Controller).first(),
             location=Location.objects.first(),
-            deployed_controller_device=Device.objects.first(),
-            deployed_controller_group=DeviceRedundancyGroup.objects.first(),
+            controller_device=Device.objects.first(),
+            controller_device_redundancy_group=DeviceRedundancyGroup.objects.first(),
         )
         with self.assertRaises(ValidationError) as error:
             controller.validated_save()
         self.assertEqual(
-            error.exception.message_dict["deployed_controller_device"][0],
+            error.exception.message_dict["controller_device"][0],
             "Cannot assign both a device and a device redundancy group to a controller.",
         )
 
@@ -1924,19 +1924,19 @@ class ControllerTestCase(ModelTestCases.BaseModelTestCase):
         )
 
 
-class ControllerDeviceGroupTestCase(ModelTestCases.BaseModelTestCase):
-    model = ControllerDeviceGroup
+class ControllerManagedDeviceGroupTestCase(ModelTestCases.BaseModelTestCase):
+    model = ControllerManagedDeviceGroup
 
     def test_controller_matches_parent(self):
         """Ensure a controller device group cannot be linked to a controller that does not match its parent."""
         controllers = iter(Controller.objects.all())
-        parent_group = ControllerDeviceGroup(
+        parent_group = ControllerManagedDeviceGroup(
             name="Parent Group testing Controller match",
             controller=next(controllers),
         )
         parent_group.validated_save()
 
-        child_group = ControllerDeviceGroup(
+        child_group = ControllerManagedDeviceGroup(
             name="Child Group testing Controller match",
             controller=next(controllers),
             parent=parent_group,
@@ -1955,37 +1955,37 @@ class ControllerDeviceGroupTestCase(ModelTestCases.BaseModelTestCase):
         controller1, controller2 = Controller.objects.all()[:2]
         self.assertNotEqual(controller1, controller2, "Controllers should be different")
 
-        parent_group = ControllerDeviceGroup.objects.create(
+        parent_group = ControllerManagedDeviceGroup.objects.create(
             name="Parent Group testing Controller match",
             controller=controller1,
         )
-        child_group1 = ControllerDeviceGroup.objects.create(
+        child_group1 = ControllerManagedDeviceGroup.objects.create(
             name="Child Group 1 testing Controller match",
             controller=controller1,
             parent=parent_group,
         )
-        child_group2 = ControllerDeviceGroup.objects.create(
+        child_group2 = ControllerManagedDeviceGroup.objects.create(
             name="Child Group 2 testing Controller match",
             controller=controller1,
             parent=child_group1,
         )
 
-        parent_group = ControllerDeviceGroup.objects.get(pk=parent_group.pk)
+        parent_group = ControllerManagedDeviceGroup.objects.get(pk=parent_group.pk)
         parent_group.controller = controller2
         parent_group.save()
 
         self.assertEqual(
-            ControllerDeviceGroup.objects.get(pk=parent_group.pk).controller,
+            ControllerManagedDeviceGroup.objects.get(pk=parent_group.pk).controller,
             controller2,
             "Parent group controller should have been updated",
         )
         self.assertEqual(
-            ControllerDeviceGroup.objects.get(pk=child_group1.pk).controller,
+            ControllerManagedDeviceGroup.objects.get(pk=child_group1.pk).controller,
             controller2,
             "Child group 1 controller should have been updated",
         )
         self.assertEqual(
-            ControllerDeviceGroup.objects.get(pk=child_group2.pk).controller,
+            ControllerManagedDeviceGroup.objects.get(pk=child_group2.pk).controller,
             controller2,
             "Child group 2 controller should have been updated",
         )

nautobot/dcim/tests/test_signals.py

@@ -1,8 +1,9 @@
-"""Tests for DCIM Signals.py """
+"""Tests for DCIM Signals.py"""
 
 from django.test import TestCase
 
 from nautobot.dcim.models import (
+    Controller,
     Device,
     DeviceRedundancyGroup,
     DeviceType,
@@ -103,6 +104,7 @@ class DeviceRedundancyGroupTest(TestCase):
         self.device.device_redundancy_group_priority = 1
         self.device.validated_save()
 
+        Controller.objects.all().delete()
         deviceredundancygroup.delete()
 
         self.device.refresh_from_db()