nautobot 2.4.3__py3-none-any.whl → 2.4.5__py3-none-any.whl

nautobot/dcim/tests/test_api.py

@@ -1716,6 +1716,182 @@ class DeviceTest(APIViewTestCases.APIViewTestCase):
         )
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
 
+    def _parent_device_test_data(self):
+        location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
+        device_status = Status.objects.get_for_model(Device).first()
+        device_role = Role.objects.get_for_model(Device).first()
+        device_type = DeviceType.objects.first()
+
+        device_type_parent = DeviceType.objects.create(
+            manufacturer=device_type.manufacturer,
+            model=f"{device_type.model} Parent",
+            u_height=device_type.u_height,
+            subdevice_role=SubdeviceRoleChoices.ROLE_PARENT,
+        )
+        device_type_child = DeviceType.objects.create(
+            manufacturer=device_type.manufacturer,
+            model=f"{device_type.model} Child",
+            u_height=device_type.u_height,
+            subdevice_role=SubdeviceRoleChoices.ROLE_CHILD,
+        )
+
+        parent_device = Device.objects.create(
+            device_type=device_type_parent,
+            role=device_role,
+            status=device_status,
+            name="Device Parent",
+            location=location,
+        )
+        device_bay_1 = DeviceBay.objects.create(name="db1", device_id=parent_device.pk)
+        device_bay_2 = DeviceBay.objects.create(name="db2", device_id=parent_device.pk)
+
+        return parent_device, device_bay_1, device_bay_2, device_type_child
+
+    def test_creating_device_with_parent_bay(self):
+        # Create test data
+        parent_device, device_bay_1, device_bay_2, device_type_child = self._parent_device_test_data()
+
+        self.add_permissions("dcim.add_device")
+        url = reverse("dcim-api:device-list")
+
+        # Test creating device with parent bay by device bay data
+        data = {
+            "device_type": device_type_child.pk,
+            "role": parent_device.role.pk,
+            "location": parent_device.location.pk,
+            "name": "Device parent bay test #1",
+            "status": parent_device.status.pk,
+            "parent_bay": {"device": {"name": parent_device.name}, "name": device_bay_1.name},
+        }
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+
+        created_device = Device.objects.get(name="Device parent bay test #1")
+        self.assertEqual(created_device.parent_bay.pk, device_bay_1.pk)
+
+        # Test creating device with parent bay by device_bay.pk
+        data = {
+            "device_type": device_type_child.pk,
+            "role": parent_device.role.pk,
+            "location": parent_device.location.pk,
+            "name": "Device parent bay test #2",
+            "status": parent_device.status.pk,
+            "parent_bay": device_bay_2.pk,
+        }
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+
+        created_device = Device.objects.get(name="Device parent bay test #2")
+        self.assertEqual(created_device.parent_bay.pk, device_bay_2.pk)
+
+        # Test creating device with parent bay already taken
+        data = {
+            "device_type": device_type_child.pk,
+            "role": parent_device.role.pk,
+            "location": parent_device.location.pk,
+            "name": "Device parent bay test #3",
+            "status": parent_device.status.pk,
+            "parent_bay": device_bay_1.pk,
+        }
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn("Cannot install device; parent bay is already taken", response.content.decode(response.charset))
+
+        # Assert that on the #1 device, parent bay stayed the same
+        old_device = Device.objects.get(name="Device parent bay test #1")
+        self.assertEqual(old_device.parent_bay.pk, device_bay_1.pk)
+
+    def test_update_device_with_parent_bay(self):
+        # Create test data
+        parent_device, device_bay_1, device_bay_2, device_type_child = self._parent_device_test_data()
+
+        self.add_permissions("dcim.change_device")
+
+        child_device = Device.objects.create(
+            device_type=device_type_child,
+            role=parent_device.role,
+            location=parent_device.location,
+            name="Device parent bay test #4",
+            status=parent_device.status,
+        )
+        # Test setting parent bay during the update
+        patch_data = {"parent_bay": device_bay_1.pk}
+        response = self.client.patch(self._get_detail_url(child_device), patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+
+        updated_device = Device.objects.get(name="Device parent bay test #4")
+        self.assertEqual(updated_device.parent_bay.pk, device_bay_1.pk)
+
+        # Changing the parent bay is not allowed without removing it first
+        patch_data = {"parent_bay": device_bay_2.pk}
+        response = self.client.patch(self._get_detail_url(child_device), patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn(
+            f"Cannot install the specified device; device is already installed in {device_bay_1.name}",
+            response.content.decode(response.charset),
+        )
+
+        # Assert that parent bay stayed the same
+        updated_device = Device.objects.get(name="Device parent bay test #4")
+        self.assertEqual(updated_device.parent_bay.pk, device_bay_1.pk)
+
+    def test_reassign_device_to_parent_bay(self):
+        # Create test data
+        parent_device, device_bay_1, device_bay_2, device_type_child = self._parent_device_test_data()
+        device_name = "Device parent bay test #5"
+        child_device = Device.objects.create(
+            device_type=device_type_child,
+            role=parent_device.role,
+            location=parent_device.location,
+            name=device_name,
+            status=parent_device.status,
+        )
+        device_bay_1.installed_device = child_device
+        device_bay_1.save()
+
+        self.add_permissions("dcim.change_device", "dcim.view_device", "dcim.change_devicebay")
+        child_device_detail_url = self._get_detail_url(child_device)
+
+        response = self.client.get(child_device_detail_url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertEqual(response.json()["parent_bay"]["id"], str(device_bay_1.pk))
+
+        # Test unassigning parent bay
+        patch_data = {"parent_bay": None}
+        response = self.client.patch(child_device_detail_url, patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+
+        child_device.refresh_from_db()
+        with self.assertRaises(DeviceBay.DoesNotExist):
+            child_device.parent_bay
+
+        # And assign it again
+        patch_data = {"parent_bay": device_bay_2.pk}
+        response = self.client.patch(child_device_detail_url, patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+
+        child_device.refresh_from_db()
+        self.assertEqual(child_device.parent_bay.pk, device_bay_2.pk)
+
+        # Unassign it through device bay
+        patch_data = {"installed_device": None}
+        response = self.client.patch(self._get_detail_url(device_bay_2), patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+
+        child_device.refresh_from_db()
+        self.assertFalse(hasattr(child_device, "parent_bay"))
+
+        # And assign through device bay
+        patch_data = {"installed_device": child_device.pk}
+        response = self.client.patch(self._get_detail_url(device_bay_1), patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+
+        child_device.refresh_from_db()
+        self.assertEqual(child_device.parent_bay.pk, device_bay_1.pk)
+
 
 class ModuleTestCase(APIViewTestCases.APIViewTestCase):
     model = Module

nautobot/dcim/tests/test_filters.py

@@ -157,6 +157,8 @@ def common_test_data(cls):
     cls.loc0 = loc0
     cls.loc1 = loc1
     cls.nested_loc = nested_loc
+    cls.loc2 = loc2
+    cls.loc3 = loc3
 
     provider = Provider.objects.first()
     circuit_type = CircuitType.objects.first()
@@ -1150,6 +1152,24 @@ class RackGroupTestCase(FilterTestCases.FilterTestCase):
             name="Rack Group 4",
             location=cls.loc1,
         )
+        RackGroup.objects.create(
+            name="Rack Group 5",
+            location=cls.loc2,
+            description="C",
+        )
+        RackGroup.objects.create(
+            name="Rack Group 6",
+            location=cls.loc2,
+        )
+        RackGroup.objects.create(
+            name="Rack Group 7",
+            location=cls.loc3,
+            description="C",
+        )
+        RackGroup.objects.create(
+            name="Rack Group 8",
+            location=cls.loc3,
+        )
 
     def test_children(self):
         child_groups = RackGroup.objects.filter(name__startswith="Child").filter(parent__isnull=False)[:2]
@@ -1161,6 +1181,24 @@ class RackGroupTestCase(FilterTestCases.FilterTestCase):
             params = {"children": [rack_group_4.pk, rack_group_4.pk]}
             self.assertFalse(self.filterset(params, self.queryset).qs.exists())
 
+    def test_ancestors(self):
+        with self.subTest():
+            pk_list = []
+            parent_locations = self.loc3.ancestors(include_self=True)
+            pk_list.extend([v.pk for v in parent_locations])
+            params = Q(location__pk__in=pk_list)
+            expected_queryset = RackGroup.objects.filter(params)
+            params = {"ancestors": [self.loc3.pk]}
+            self.assertQuerysetEqualAndNotEmpty(self.filterset(params, self.queryset).qs, expected_queryset)
+        with self.subTest():
+            pk_list = []
+            parent_locations = self.loc2.ancestors(include_self=True)
+            pk_list.extend([v.pk for v in parent_locations])
+            params = Q(location__pk__in=pk_list)
+            expected_queryset = RackGroup.objects.filter(params)
+            params = {"ancestors": [self.loc2.pk]}
+            self.assertQuerysetEqualAndNotEmpty(self.filterset(params, self.queryset).qs, expected_queryset)
+
 
 class RackTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
     queryset = Rack.objects.all()
@@ -4188,12 +4226,13 @@ class InterfaceVDCAssignmentTestCase(FilterTestCases.FilterTestCase):
 
     @classmethod
     def setUpTestData(cls):
-        device = Device.objects.first()
+        device_1 = Device.objects.first()
+        device_2 = Device.objects.last()
         vdc_status = Status.objects.get_for_model(VirtualDeviceContext)[0]
         interface_status = Status.objects.get_for_model(Interface)[0]
         interfaces = [
             Interface.objects.create(
-                device=device,
+                device=device_1,
                 type=InterfaceTypeChoices.TYPE_1GE_FIXED,
                 name=f"Interface 00{idx}",
                 status=interface_status,
@@ -4202,7 +4241,7 @@ class InterfaceVDCAssignmentTestCase(FilterTestCases.FilterTestCase):
         ]
         vdcs = [
             VirtualDeviceContext.objects.create(
-                device=device,
+                device=device_1,
                 status=vdc_status,
                 identifier=200 + idx,
                 name=f"Test VDC {idx}",
@@ -4213,3 +4252,17 @@ class InterfaceVDCAssignmentTestCase(FilterTestCases.FilterTestCase):
         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])
+        InterfaceVDCAssignment.objects.create(
+            virtual_device_context=VirtualDeviceContext.objects.create(
+                device=device_2,
+                status=vdc_status,
+                identifier=200,
+                name="Test VDC 0",
+            ),
+            interface=Interface.objects.create(
+                device=device_2,
+                type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+                name="Interface 000",
+                status=interface_status,
+            ),
+        )

nautobot/dcim/tests/test_jobs.py

@@ -71,7 +71,7 @@ def create_common_data_for_software_related_test_cases():
 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()
+        software_image_file = SoftwareImageFile.objects.get(image_file_name="software_image_file_qs_test_1.bin")
 
         self.add_permissions("dcim.delete_softwareimagefile")
         pk_list = [str(software_image_file.pk)]
@@ -86,9 +86,7 @@ class TestSoftwareImageFileTestCase(TransactionTestCase):
             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)
+        self.assertJobResultStatus(job_result, 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())
@@ -97,7 +95,7 @@ class TestSoftwareImageFileTestCase(TransactionTestCase):
 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()
+        software_version = SoftwareVersion.objects.get(version="Test version 1.0.0")
 
         initial_count = SoftwareVersion.objects.all().count()
         self.add_permissions("dcim.delete_softwareversion")
@@ -112,7 +110,7 @@ class TestSoftwareVersionTestCase(TransactionTestCase):
             pk_list=pk_list,
             username=self.user.username,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, 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

@@ -1166,6 +1166,19 @@ class LocationTypeTestCase(TestCase):
         child_loc.delete()
         child.validated_save()
 
+    def test_removing_content_type(self):
+        """Validation check to prevent removing an in-use content type from a LocationType."""
+
+        location_type = LocationType.objects.get(name="Campus")
+        device_ct = ContentType.objects.get_for_model(Device)
+
+        with self.assertRaises(ValidationError) as cm:
+            location_type.content_types.remove(device_ct)
+        self.assertIn(
+            f"Cannot remove the content type {device_ct} as currently at least one device is associated to a location",
+            str(cm.exception),
+        )
+
 
 class LocationTestCase(ModelTestCases.BaseModelTestCase):
     model = Location
@@ -1895,6 +1908,33 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
         parent_device.rack = rack
         parent_device.save()
 
+        # Test assigning a rack in the child location of the parent device location
+        location_status = Status.objects.get_for_model(Location).first()
+        child_location = Location.objects.create(
+            name="Child Location 1",
+            location_type=self.location_type_3,
+            status=location_status,
+            parent=parent_device.location,
+        )
+        child_rack = Rack.objects.create(name="Rack 2", location=child_location, status=self.device_status)
+        parent_device.rack = child_rack
+        parent_device.validated_save()
+
+        # Test assigning a rack outside the child locations of the parent device location
+        new_location = Location.objects.create(
+            name="New Location 1",
+            status=location_status,
+            location_type=self.location_type_3,
+        )
+        invalid_rack = Rack.objects.create(name="Rack 3", location=new_location, status=self.device_status)
+        parent_device.rack = invalid_rack
+        with self.assertRaises(ValidationError) as cm:
+            parent_device.validated_save()
+        self.assertIn(
+            f'Rack "{invalid_rack}" does not belong to location "{parent_device.location}" and its descendants.',
+            str(cm.exception),
+        )
+
         child_mtime_after_parent_rack_update_save = str(Device.objects.get(name="Child Device 1").last_updated)
 
         self.assertNotEqual(child_mtime_after_parent_noop_save, child_mtime_after_parent_rack_update_save)

nautobot/dcim/views.py

@@ -61,7 +61,7 @@ from nautobot.dcim.utils import get_all_network_driver_mappings, get_network_dri
 from nautobot.extras.models import Contact, ContactAssociation, Role, Status, Team
 from nautobot.extras.views import ObjectChangeLogView, ObjectConfigContextView, ObjectDynamicGroupsView
 from nautobot.ipam.models import IPAddress, Prefix, Service, VLAN
-from nautobot.ipam.tables import InterfaceIPAddressTable, InterfaceVLANTable, VRFDeviceAssignmentTable
+from nautobot.ipam.tables import InterfaceIPAddressTable, InterfaceVLANTable, VRFDeviceAssignmentTable, VRFTable
 from nautobot.virtualization.models import VirtualMachine
 from nautobot.wireless.forms import ControllerManagedDeviceGroupWirelessNetworkFormSet
 from nautobot.wireless.models import (
@@ -1922,7 +1922,7 @@ class DeviceView(generic.ObjectView):
 
         # VRF assignments
         vrf_assignments = instance.vrf_assignments.restrict(request.user, "view")
-        vrf_table = VRFDeviceAssignmentTable(vrf_assignments, exclude=("virtual_machine", "device"))
+        vrf_table = VRFDeviceAssignmentTable(vrf_assignments)
 
         # Software images
         if instance.software_version is not None:
@@ -4513,15 +4513,25 @@ class VirtualDeviceContextUIViewSet(NautobotUIViewSet):
     queryset = VirtualDeviceContext.objects.all()
     serializer_class = serializers.VirtualDeviceContextSerializer
     table_class = tables.VirtualDeviceContextTable
-
-    def get_extra_context(self, request, instance):
-        if self.action == "retrieve":
-            interfaces_table = tables.InterfaceTable(
-                instance.interfaces.restrict(request.user, "view"), orderable=False, exclude=("device",)
-            )
-
-            return {
-                "interfaces_table": interfaces_table,
-                **super().get_extra_context(request, instance),
-            }
-        return super().get_extra_context(request, instance)
+    object_detail_content = object_detail.ObjectDetailContent(
+        panels=(
+            object_detail.ObjectFieldsPanel(
+                section=SectionChoices.LEFT_HALF,
+                weight=100,
+                fields="__all__",
+            ),
+            object_detail.ObjectsTablePanel(
+                weight=200,
+                table_class=tables.InterfaceTable,
+                table_attribute="interfaces",
+                section=SectionChoices.FULL_WIDTH,
+                exclude_columns=["device"],
+            ),
+            object_detail.ObjectsTablePanel(
+                weight=300,
+                table_class=VRFTable,
+                table_attribute="vrfs",
+                section=SectionChoices.FULL_WIDTH,
+            ),
+        ),
+    )

nautobot/extras/api/mixins.py

@@ -37,7 +37,7 @@ class TaggedModelSerializerMixin(BaseModelSerializer):
 
     def _save_tags(self, instance, tags):
         if tags:
-            instance.tags.set([t.name for t in tags])
+            instance.tags.set(tags)
         else:
             instance.tags.clear()
 

nautobot/extras/api/views.py

@@ -642,7 +642,7 @@ class JobViewSetBase(
             ):
                 raise ValidationError(
                     {
-                        "_task_queue": "_task_queue and _job_queue are both specified. Please specifiy only one or another."
+                        "_task_queue": "_task_queue and _job_queue are both specified. Please specify only one or another."
                     }
                 )
 
@@ -685,7 +685,7 @@ class JobViewSetBase(
                 "job_queue", None
             ):
                 raise ValidationError(
-                    {"task_queue": "task_queue and job_queue are both specified. Please specifiy only one or another."}
+                    {"task_queue": "task_queue and job_queue are both specified. Please specify only one or another."}
                 )
             schedule_data = input_serializer.validated_data.get("schedule", None)
 

nautobot/extras/choices.py

@@ -251,8 +251,10 @@ class JobResultStatusChoices(ChoiceSet):
     """
 
     STATUS_FAILURE = states.FAILURE
+    STATUS_IGNORED = states.IGNORED
     STATUS_PENDING = states.PENDING
     STATUS_RECEIVED = states.RECEIVED
+    STATUS_REJECTED = states.REJECTED
     STATUS_RETRY = states.RETRY
     STATUS_REVOKED = states.REVOKED
     STATUS_STARTED = states.STARTED
@@ -302,27 +304,30 @@ class JobResultStatusChoices(ChoiceSet):
 class LogLevelChoices(ChoiceSet):
     LOG_DEBUG = "debug"
     LOG_INFO = "info"
+    LOG_SUCCESS = "success"
     LOG_WARNING = "warning"
+    LOG_FAILURE = "failure"
     LOG_ERROR = "error"
     LOG_CRITICAL = "critical"
-    LOG_SUCCESS = "success"
 
     CHOICES = (
         (LOG_DEBUG, "Debug"),
         (LOG_INFO, "Info"),
+        (LOG_SUCCESS, "Success"),
         (LOG_WARNING, "Warning"),
+        (LOG_FAILURE, "Failure"),
         (LOG_ERROR, "Error"),
         (LOG_CRITICAL, "Critical"),
-        (LOG_SUCCESS, "Success"),
     )
 
     CSS_CLASSES = {
         LOG_DEBUG: "debug",
         LOG_INFO: "info",
+        LOG_SUCCESS: "success",
         LOG_WARNING: "warning",
+        LOG_FAILURE: "failure",
         LOG_ERROR: "error",
         LOG_CRITICAL: "critical",
-        LOG_SUCCESS: "success",
     }
 
 

nautobot/extras/filters/__init__.py

@@ -854,6 +854,10 @@ class JobFilterSet(BaseFilterSet, CustomFieldModelFilterSetMixin):
             "description": "icontains",
         },
     )
+    job_queues = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=JobQueue.objects.all(),
+        label="Job Queue (name or ID)",
+    )
 
     class Meta:
         model = Job