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

nautobot/core/tests/test_jobs.py

@@ -1,4 +1,5 @@
 from datetime import timedelta
+import json
 from pathlib import Path
 
 from django.contrib.contenttypes.models import ContentType
@@ -9,6 +10,7 @@ import yaml
 
 from nautobot.core.jobs.cleanup import CleanupTypes
 from nautobot.core.testing import create_job_result_and_run_job, TransactionTestCase
+from nautobot.core.testing.context import load_event_broker_override_settings
 from nautobot.dcim.models import Device, DeviceType, Location, LocationType, Manufacturer
 from nautobot.extras.choices import JobResultStatusChoices, LogLevelChoices
 from nautobot.extras.factory import JobResultFactory, ObjectChangeFactory
@@ -22,8 +24,10 @@ from nautobot.extras.models import (
     ObjectChange,
     Role,
     Status,
+    Tag,
 )
-from nautobot.ipam.models import Prefix
+from nautobot.extras.models.metadata import ObjectMetadata
+from nautobot.ipam.models import Namespace, Prefix
 from nautobot.users.models import ObjectPermission
 
 
@@ -438,6 +442,16 @@ class LogsCleanupTestCase(TransactionTestCase):
         if JobResult.objects.count() < 2:
             JobResultFactory.create_batch(20)
 
+    @load_event_broker_override_settings(
+        EVENT_BROKERS={
+            "SyslogEventBroker": {
+                "CLASS": "nautobot.core.events.SyslogEventBroker",
+                "TOPICS": {
+                    "INCLUDE": ["*"],
+                },
+            }
+        }
+    )
     def test_cleanup_without_permission(self):
         """Job should enforce user permissions on the content-types being deleted."""
         job_result_count = JobResult.objects.count()
@@ -458,13 +472,14 @@ class LogsCleanupTestCase(TransactionTestCase):
         self.assertGreater(JobLogEntry.objects.count(), job_log_entry_count)
         self.assertEqual(ObjectChange.objects.count(), object_change_count)
 
-        job_result = create_job_result_and_run_job(
-            "nautobot.core.jobs.cleanup",
-            "LogsCleanup",
-            username=self.user.username,
-            cleanup_types=[CleanupTypes.OBJECT_CHANGE],
-            max_age=0,
-        )
+        with self.assertLogs("nautobot.events") as cm:
+            job_result = create_job_result_and_run_job(
+                "nautobot.core.jobs.cleanup",
+                "LogsCleanup",
+                username=self.user.username,
+                cleanup_types=[CleanupTypes.OBJECT_CHANGE],
+                max_age=0,
+            )
         self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
         log_error = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
         self.assertEqual(
@@ -474,6 +489,21 @@ class LogsCleanupTestCase(TransactionTestCase):
         self.assertGreater(JobLogEntry.objects.count(), job_log_entry_count)
         self.assertEqual(ObjectChange.objects.count(), object_change_count)
 
+        complete_logs = {
+            "job_result_id": str(job_result.id),
+            "job_name": "Logs Cleanup",
+            "user_name": self.user.username,
+            "job_kwargs": {"cleanup_types": ["extras.ObjectChange"], "max_age": 0},
+            "einfo": {
+                "exc_type": "PermissionDenied",
+                "exc_message": "User does not have delete permissions for ObjectChange records",
+            },
+        }
+        self.assertEqual(
+            cm.output[1],
+            f"INFO:nautobot.events.nautobot.jobs.job.completed:{json.dumps(complete_logs, indent=4)}",
+        )
+
     def test_cleanup_with_constrained_permission(self):
         """Job should only allow the user to cleanup records they have permission to delete."""
         job_result_1 = JobResult.objects.last()
@@ -508,20 +538,62 @@ class LogsCleanupTestCase(TransactionTestCase):
             ObjectChange.objects.get(pk=object_change_1.pk)
         ObjectChange.objects.get(pk=object_change_2.pk)
 
+    @load_event_broker_override_settings(
+        EVENT_BROKERS={
+            "SyslogEventBroker": {
+                "CLASS": "nautobot.core.events.SyslogEventBroker",
+                "TOPICS": {
+                    "INCLUDE": ["*"],
+                },
+            }
+        }
+    )
     def test_cleanup_job_results(self):
         """With unconstrained permissions, all JobResults before the cutoff should be deleted."""
         cutoff = timezone.now() - timedelta(days=60)
-        create_job_result_and_run_job(
-            "nautobot.core.jobs.cleanup",
-            "LogsCleanup",
-            cleanup_types=[CleanupTypes.JOB_RESULT],
-            max_age=60,
-        )
+        job_results_to_be_deleted = JobResult.objects.filter(date_done__lt=cutoff)
+        job_results_to_be_deleted_count = job_results_to_be_deleted.count()
+        job_log_entry_to_be_deleted_count = JobLogEntry.objects.filter(job_result__in=job_results_to_be_deleted).count()
+        objectmetadata_to_be_deleted_count = ObjectMetadata.objects.filter(
+            assigned_object_id__in=job_results_to_be_deleted,
+            assigned_object_type=ContentType.objects.get_for_model(JobResult),
+        ).count()
+
+        with self.assertLogs("nautobot.events") as cm:
+            job_result = create_job_result_and_run_job(
+                "nautobot.core.jobs.cleanup",
+                "LogsCleanup",
+                cleanup_types=[CleanupTypes.JOB_RESULT],
+                max_age=60,
+            )
         self.assertFalse(JobResult.objects.filter(date_done__lt=cutoff).exists())
         self.assertTrue(JobResult.objects.filter(date_done__gte=cutoff).exists())
         self.assertTrue(ObjectChange.objects.filter(time__lt=cutoff).exists())
         self.assertTrue(ObjectChange.objects.filter(time__gte=cutoff).exists())
 
+        started_logs = {
+            "job_result_id": str(job_result.id),
+            "job_name": "Logs Cleanup",
+            "user_name": job_result.user.username,
+            "job_kwargs": {"cleanup_types": ["extras.JobResult"], "max_age": 60},
+        }
+        self.assertEqual(
+            cm.output[0],
+            f"INFO:nautobot.events.nautobot.jobs.job.started:{json.dumps(started_logs, indent=4)}",
+        )
+
+        started_logs["job_output"] = {
+            "extras.JobResult": job_results_to_be_deleted_count,
+            "extras.JobLogEntry": job_log_entry_to_be_deleted_count,
+        }
+        if objectmetadata_to_be_deleted_count > 0:
+            started_logs["job_output"]["extras.ObjectMetadata"] = objectmetadata_to_be_deleted_count
+
+        self.assertEqual(
+            cm.output[1],
+            f"INFO:nautobot.events.nautobot.jobs.job.completed:{json.dumps(started_logs, indent=4)}",
+        )
+
     def test_cleanup_object_changes(self):
         """With unconstrained permissions, all ObjectChanges before the cutoff should be deleted."""
         cutoff = timezone.now() - timedelta(days=60)
@@ -535,3 +607,304 @@ class LogsCleanupTestCase(TransactionTestCase):
         self.assertTrue(JobResult.objects.filter(date_done__gte=cutoff).exists())
         self.assertFalse(ObjectChange.objects.filter(time__lt=cutoff).exists())
         self.assertTrue(ObjectChange.objects.filter(time__gte=cutoff).exists())
+
+
+class BulkEditTestCase(TransactionTestCase):
+    """
+    Test the BulkEdit system job.
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.status_ct = ContentType.objects.get_for_model(Status)
+        self.namespace_ct = ContentType.objects.get_for_model(Namespace)
+        self.role_ct = ContentType.objects.get_for_model(Role)
+        self.tags = [Tag.objects.create(name=f"Example Tag {x}") for x in range(5)]
+        for tag in self.tags:
+            tag.content_types.add(self.namespace_ct)
+
+    def _common_no_error_test_assertion(self, model, job_result, expected_count, **filter_params):
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertEqual(model.objects.filter(**filter_params).count(), expected_count)
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING).exists()
+        )
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR).exists()
+        )
+
+    def test_bulk_edit_without_permission(self):
+        statuses = [Status.objects.create(name=f"Sample Status {x}") for x in range(3)]
+        pk_list = [str(status.id) for status in statuses]
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=self.status_ct.id,
+            edit_all=False,
+            filter_query_params={},
+            form_data={"pk": pk_list, "color": "aa1409"},
+            username=self.user.username,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        job_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertEqual(job_log.message, f'User "{self.user}" does not have permission to update status objects')
+
+        # Assert status did not get updated
+        for status in statuses:
+            status.refresh_from_db()
+            self.assertNotEqual(status.color, "aa1409")
+
+    def test_bulk_edit_all(self):
+        self.add_permissions("extras.change_role", "extras.view_role")
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=self.role_ct.id,
+            edit_all=True,
+            filter_query_params={},
+            form_data={"color": "aa1409"},
+            username=self.user.username,
+        )
+        self._common_no_error_test_assertion(Role, job_result, Role.objects.all().count(), color="aa1409")
+
+    def test_bulk_edit_filter_all(self):
+        self.add_permissions("extras.change_status", "extras.view_status")
+        # By default Active and Available are some of the example of Status that starts with A
+        statuses = Status.objects.filter(name__istartswith="A")
+        status_to_ignore = Status.objects.create(name="Ignore Example Status")
+        self.assertNotEqual(statuses.count(), 0)
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=self.status_ct.id,
+            edit_all=True,
+            filter_query_params={"name__isw": "A"},
+            # pk ignored if edit_all is True
+            form_data={
+                "pk": [str(statuses[0].pk)],
+                "color": "aa1409",
+                "_all": "True",
+            },
+            username=self.user.username,
+        )
+        self._common_no_error_test_assertion(
+            Status, job_result, statuses.count(), name__istartswith="A", color="aa1409"
+        )
+        self.assertNotEqual(status_to_ignore.color, "aa1409")
+
+    def test_bulk_edit_with_pk(self):
+        self.add_permissions("ipam.change_namespace", "ipam.view_namespace", "extras.change_tag", "extras.view_tag")
+        namespaces = [Namespace.objects.create(name=f"Sample Namespace {x}") for x in range(5)]
+        for namespace in namespaces:
+            namespace.tags.set(self.tags[3:])
+        pk_list = [str(status.id) for status in namespaces[:3]]
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=self.namespace_ct.id,
+            edit_all=False,
+            filter_query_params={},
+            form_data={
+                "pk": pk_list,
+                "description": "Example description for bulk edit",
+                "add_tags": [str(tag.id) for tag in self.tags[:3]],
+                "remove_tags": [str(tag.id) for tag in self.tags[3:]],
+            },
+            username=self.user.username,
+        )
+
+        self._common_no_error_test_assertion(
+            Namespace,
+            job_result,
+            3,
+            description="Example description for bulk edit",
+        )
+
+        # Assert Namespaces withing pk_list updated tags
+        for namespace in namespaces[:3]:
+            self.assertTrue(namespace.tags.filter(pk__in=[tag.pk for tag in self.tags[:3]]).exists())
+            self.assertFalse(namespace.tags.filter(pk__in=[tag.pk for tag in self.tags[3:]]).exists())
+
+        # Assert Namespaces not withing pk_list tags did not get updated
+        for namespace in namespaces[3:]:
+            self.assertFalse(namespace.tags.filter(pk__in=[tag.pk for tag in self.tags[:3]]).exists())
+            self.assertTrue(namespace.tags.filter(pk__in=[tag.pk for tag in self.tags[3:]]).exists())
+
+    def test_bulk_edit_objects_with_constrained_permission(self):
+        roles_to_update = [
+            Role.objects.create(name="Example Role 1"),
+            Role.objects.create(name="Example Role 2"),
+        ]
+        pk_list = [str(role.pk) for role in roles_to_update]
+
+        obj_perm = ObjectPermission.objects.create(
+            name="Test permission",
+            constraints={"pk": pk_list[0]},
+            actions=["change", "view"],
+        )
+        obj_perm.users.add(self.user)
+        obj_perm.object_types.add(self.role_ct)
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=self.role_ct.id,
+            edit_all=False,
+            filter_query_params={},
+            form_data={"pk": pk_list, "color": "aa1409"},
+            username=self.user.username,
+        )
+        error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertIn("Form validation unsuccessful", error_log.message)
+        self.assertIn(f"{roles_to_update[1].pk} is not one of the available choices.", error_log.message)
+        roles_to_update[0].refresh_from_db()
+        roles_to_update[1].refresh_from_db()
+        self.assertNotEqual(roles_to_update[0].color, "aa1409")
+        self.assertNotEqual(roles_to_update[1].color, "aa1409")
+
+        obj_perm.constraints = {"pk__in": pk_list}
+        obj_perm.save()
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=self.role_ct.id,
+            edit_all=False,
+            filter_query_params={},
+            form_data={"pk": pk_list, "color": "aa1409"},
+            username=self.user.username,
+        )
+        self._common_no_error_test_assertion(Role, job_result, 2, pk__in=pk_list, color="aa1409")
+
+
+class BulkDeleteTestCase(TransactionTestCase):
+    """
+    Test the BulkDelete system job.
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.status_ct = ContentType.objects.get_for_model(Status)
+        self.role_ct = ContentType.objects.get_for_model(Role)
+        self.device_ct = ContentType.objects.get_for_model(Device)
+
+    def _common_no_error_test_assertion(self, model, job_result, **filter_params):
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertEqual(model.objects.filter(**filter_params).count(), 0)
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING).exists()
+        )
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR).exists()
+        )
+
+    def test_bulk_delete_without_permission(self):
+        statuses_to_delete = [str(status) for status in Status.objects.all().values_list("pk", flat=True)[:2]]
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=self.status_ct.id,
+            pk_list=statuses_to_delete,
+            username=self.user.username,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        job_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertEqual(job_log.message, f'User "{self.user}" does not have permission to delete status objects')
+        self.assertEqual(Status.objects.filter(pk__in=statuses_to_delete).count(), len(statuses_to_delete))
+
+    def test_bulk_delete_objects_with_constrained_permission(self):
+        statuses_to_delete = [str(status) for status in Status.objects.all().values_list("pk", flat=True)[:2]]
+        obj_perm = ObjectPermission(
+            name="Test permission",
+            constraints={"pk": str(statuses_to_delete[0])},
+            actions=["delete"],
+        )
+        obj_perm.save()
+        obj_perm.users.add(self.user)
+        obj_perm.object_types.add(ContentType.objects.get_for_model(Status))
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=self.status_ct.id,
+            pk_list=statuses_to_delete,
+            username=self.user.username,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertEqual(
+            error_log.message, "You do not have permissions to delete some of the objects provided in `pk_list`."
+        )
+        self.assertEqual(Status.objects.filter(pk__in=statuses_to_delete).count(), len(statuses_to_delete))
+
+    def test_bulk_delete_all(self):
+        self.add_permissions("extras.delete_objectmetadata")
+
+        # Assert ObjectMetadata is not empty
+        self.assertNotEqual(ObjectMetadata.objects.all().count(), 0)
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=ContentType.objects.get_for_model(ObjectMetadata).id,
+            delete_all=True,
+            filter_query_params={},
+            pk_list=[],
+            username=self.user.username,
+        )
+        self._common_no_error_test_assertion(ObjectMetadata, job_result)
+
+    def test_bulk_delete_filter_all(self):
+        self.add_permissions("extras.delete_status")
+        for x in range(10):
+            Status.objects.create(name=f"Example Status {x}")
+
+        status_to_ignore = Status.objects.create(name="Ignore Example Status")
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=self.status_ct.id,
+            delete_all=True,
+            filter_query_params={"name__isw": "Example Status"},
+            username=self.user.username,
+        )
+        self._common_no_error_test_assertion(Status, job_result, name__istartswith="Example Status")
+        self.assertTrue(Status.objects.filter(name=status_to_ignore.name).exists())
+
+    def test_bulk_delete_passing_both_pk_list_and_delete_all(self):
+        self.add_permissions("extras.delete_status")
+        status_count = Status.objects.all().count()
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=self.status_ct.id,
+            delete_all=True,
+            filter_query_params={"name__isw": "Example Status"},
+            pk_list=[str(Status.objects.first().pk)],
+            username=self.user.username,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        job_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertEqual(
+            job_log.message,
+            "You can either delete objs within `pk_list` provided or `delete_all` with `filter_query_params` if needed.",
+        )
+        self.assertEqual(status_count, Status.objects.all().count())
+
+    def test_bulk_delete_with_pk(self):
+        self.add_permissions("extras.delete_role")
+        roles_to_delete = [Role.objects.create(name=f"Example Role {x}") for x in range(3)]
+        roles_to_ignore = Role.objects.create(name="Ignore Example Role")
+        roles_pks = [str(role.pk) for role in roles_to_delete]
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=self.role_ct.id,
+            delete_all=False,
+            filter_query_params={},
+            pk_list=roles_pks,
+            username=self.user.username,
+        )
+        self._common_no_error_test_assertion(Role, job_result, pk__in=roles_pks)
+        self.assertTrue(Role.objects.filter(name=roles_to_ignore.name).exists())