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

nautobot/extras/tests/test_relationships.py

@@ -12,12 +12,13 @@ from nautobot.core.forms import (
     DynamicModelMultipleChoiceField,
 )
 from nautobot.core.tables import RelationshipColumn
-from nautobot.core.testing import TestCase
+from nautobot.core.testing import create_job_result_and_run_job, TestCase, TransactionTestCase
 from nautobot.core.testing.models import ModelTestCases
 from nautobot.core.utils.lookup import get_route_for_model
 from nautobot.dcim.forms import DeviceForm
 from nautobot.dcim.models import (
     Controller,
+    ControllerManagedDeviceGroup,
     Device,
     DeviceType,
     DeviceTypeToSoftwareImageFile,
@@ -28,9 +29,22 @@ from nautobot.dcim.models import (
 )
 from nautobot.dcim.tables import LocationTable
 from nautobot.dcim.tests.test_views import create_test_device
-from nautobot.extras.choices import RelationshipRequiredSideChoices, RelationshipSideChoices, RelationshipTypeChoices
-from nautobot.extras.models import Relationship, RelationshipAssociation, Role, Status
-from nautobot.ipam.models import VLAN, VLANGroup
+from nautobot.extras.choices import (
+    JobResultStatusChoices,
+    LogLevelChoices,
+    RelationshipRequiredSideChoices,
+    RelationshipSideChoices,
+    RelationshipTypeChoices,
+)
+from nautobot.extras.models import (
+    Relationship,
+    RelationshipAssociation,
+    Role,
+    Status,
+)
+from nautobot.extras.models.jobs import JobLogEntry
+from nautobot.ipam.models import IPAddress, Prefix, VLAN, VLANGroup
+from nautobot.wireless.models import ControllerManagedDeviceGroupWirelessNetworkAssignment
 
 
 class RelationshipBaseTest:
@@ -353,20 +367,24 @@ class RelationshipTest(RelationshipBaseTest, ModelTestCases.BaseModelTestCase):
         self.assertFalse(field.required)
         self.assertIsInstance(field, DynamicModelMultipleChoiceField)
         self.assertEqual(field.label, "My VLANs")
-        self.assertEqual(field.query_params, {})
+        self.assertEqual(field.query_params, {"exclude_m2m": "true"})
 
         field = self.m2m_1.to_form_field("destination")
         self.assertFalse(field.required)
         self.assertIsInstance(field, DynamicModelMultipleChoiceField)
         self.assertEqual(field.label, "My Racks")
         self.assertEqual(
-            field.query_params, {"location": [self.locations[0].name, self.locations[1].name, self.locations[2].name]}
+            field.query_params,
+            {
+                "location": [self.locations[0].name, self.locations[1].name, self.locations[2].name],
+                "exclude_m2m": "true",
+            },
         )
 
         field = self.m2ms_1.to_form_field("peer")
         self.assertFalse(field.required)
         self.assertIsInstance(field, DynamicModelMultipleChoiceField)
-        self.assertEqual(field.query_params, {})
+        self.assertEqual(field.query_params, {"exclude_m2m": "true"})
 
     def test_to_form_field_o2m(self):
         field = self.o2m_1.to_form_field("source")
@@ -1393,8 +1411,10 @@ class RequiredRelationshipTestMixin:
         # Protected FK to SoftwareImageFile prevents deletion
         DeviceTypeToSoftwareImageFile.objects.all().delete()
         # Protected FK to SoftwareVersion prevents deletion
-        Controller.objects.all().delete()
         Device.objects.all().update(software_version=None)
+
+        ControllerManagedDeviceGroup.objects.all().delete()
+        Controller.objects.all().delete()
         Device.objects.all().delete()
 
         # Create required relationships:
@@ -1429,7 +1449,7 @@ class RequiredRelationshipTestMixin:
             required_on="source",
         )
         relationship_o2o.validated_save()
-        vlan_group = VLANGroup.objects.first()
+        vlan_group = VLANGroup.objects.create(name="Test VLANGroup 1")
 
         tests_params = [
             # Required many-to-many:
@@ -1709,3 +1729,97 @@ class RequiredRelationshipTestMixin:
                         }
                     }
                     self.assertEqual(expected_error_json, response.json())
+
+
+class RelationshipJobTestCase(RequiredRelationshipTestMixin, TransactionTestCase):
+    databases = ("default", "job_logs")
+
+    def create_job(self, pk_list, **extra_form_data):
+        """"""
+        vlan_ct = ContentType.objects.get_for_model(VLAN)
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=vlan_ct.id,
+            edit_all=False,
+            filter_query_params={},
+            form_data={"pk": pk_list, **extra_form_data},
+            username=self.user.username,
+        )
+        return job_result
+
+    def test_required_relationships(self):
+        """
+        1. Try creating an object when no required target object exists
+        2. Try creating an object without specifying required target object(s)
+        3. Try creating an object when all required data is present
+        4. Test bulk edit
+        """
+
+        # Delete existing factory generated objects that may interfere with this test
+        IPAddress.objects.all().delete()
+        Prefix.objects.update(parent=None)
+        Prefix.objects.all().delete()
+        ControllerManagedDeviceGroupWirelessNetworkAssignment.objects.all().delete()
+        VLAN.objects.all().delete()
+
+        # Parameterized tests (for creating and updating single objects):
+        self.required_relationships_test(interact_with="ui")
+
+        # 4. Bulk create/edit tests:
+
+        vlan_status = Status.objects.get_for_model(VLAN).first()
+        vlans = (
+            VLAN.objects.create(name="test_required_relationships1", vid=1, status=vlan_status),
+            VLAN.objects.create(name="test_required_relationships2", vid=2, status=vlan_status),
+            VLAN.objects.create(name="test_required_relationships3", vid=3, status=vlan_status),
+            VLAN.objects.create(name="test_required_relationships4", vid=4, status=vlan_status),
+            VLAN.objects.create(name="test_required_relationships5", vid=5, status=vlan_status),
+            VLAN.objects.create(name="test_required_relationships6", vid=6, status=vlan_status),
+        )
+
+        # Try deleting all devices and then editing the 6 VLANs (fails):
+        Controller.objects.filter(controller_device__isnull=False).delete()
+        Device.objects.all().delete()
+
+        pk_list = [str(vlan.id) for vlan in vlans]
+        job_result = self.create_job(pk_list)
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertIn("VLANs require at least one device, but no devices exist yet.", error_log.message)
+
+        # Create test device for association
+        device_for_association = create_test_device("VLAN Required Device")
+
+        # Try editing all 6 VLANs without adding the required device(fails):
+        job_result = self.create_job(pk_list)
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertIn(
+            '6 VLANs require a device for the required relationship \\"VLANs require at least one Device',
+            error_log.message,
+        )
+
+        # Try editing 3 VLANs without adding the required device(fails):
+        job_result = self.create_job(pk_list[:3])
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertIn(
+            'These VLANs require a device for the required relationship \\"VLANs require at least one Device',
+            error_log.message,
+        )
+        for vlan in vlans[:3]:
+            self.assertIn(str(vlan), error_log.message)
+
+        # Try editing 6 VLANs and adding the required device (succeeds):
+        job_result = self.create_job(pk_list, add_cr_vlans_devices_m2m__source=[str(device_for_association.id)])
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+
+        # Try editing 6 VLANs and removing the required device (fails):
+        job_result = self.create_job(pk_list, remove_cr_vlans_devices_m2m__source=[str(device_for_association.id)])
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertIn(
+            '6 VLANs require a device for the required relationship \\"VLANs require at least one Device',
+            error_log.message,
+        )

nautobot/extras/tests/test_utils.py

@@ -1,8 +1,11 @@
 from unittest import mock
+import uuid
 
 from django.core.cache import cache
 
 from nautobot.core.testing import TestCase
+from nautobot.extras.choices import JobQueueTypeChoices
+from nautobot.extras.models import JobQueue
 from nautobot.extras.registry import registry
 from nautobot.extras.utils import get_celery_queues, get_worker_count, populate_model_features_registry
 
@@ -45,14 +48,32 @@ class UtilsTestCase(TestCase):
     @mock.patch("nautobot.extras.utils.get_celery_queues")
     def test_get_worker_count(self, mock_get_celery_queues):
         mock_get_celery_queues.return_value = {"default": 12, "priority": 2, "bulk": 4, "nobody": 0}
+        JobQueue.objects.get_or_create(name="default", defaults={"queue_type": JobQueueTypeChoices.TYPE_CELERY})
+        priority_job_queue, _ = JobQueue.objects.get_or_create(
+            name="priority", defaults={"queue_type": JobQueueTypeChoices.TYPE_CELERY}
+        )
+        bulk_job_queue, _ = JobQueue.objects.get_or_create(
+            name="bulk", defaults={"queue_type": JobQueueTypeChoices.TYPE_CELERY}
+        )
+        empty_job_queue, _ = JobQueue.objects.get_or_create(
+            name="nobody", defaults={"queue_type": JobQueueTypeChoices.TYPE_CELERY}
+        )
         with self.subTest("Nonexistent queue"):
             self.assertEqual(get_worker_count(queue="invalid"), 0)
         with self.subTest("Default queue"):
             self.assertEqual(get_worker_count(), 12)
+        with self.subTest("Priority queue"):
+            self.assertEqual(get_worker_count(queue=priority_job_queue.name), 2)
         with self.subTest("Bulk queue"):
-            self.assertEqual(get_worker_count(queue="bulk"), 4)
+            self.assertEqual(get_worker_count(queue=bulk_job_queue.name), 4)
         with self.subTest("Empty queue"):
-            self.assertEqual(get_worker_count(queue="nobody"), 0)
+            self.assertEqual(get_worker_count(queue=empty_job_queue.name), 0)
+        with self.subTest("Passing a job queue instance"):
+            self.assertEqual(get_worker_count(queue=bulk_job_queue), 4)
+        with self.subTest("Passing a job queue pk"):
+            self.assertEqual(get_worker_count(queue=str(bulk_job_queue.pk)), 4)
+        with self.subTest("Passing a random uuid"):
+            self.assertEqual(get_worker_count(queue=str(uuid.uuid4())), 0)
 
     def test_populate_model_features_registry(self):
         original_custom_fields_registry = registry["model_features"]["custom_fields"].copy()