nautobot 2.4.0b1__py3-none-any.whl → 2.4.2__py3-none-any.whl

nautobot/extras/tests/test_jobs.py

@@ -37,7 +37,9 @@ from nautobot.extras.choices import (
     ObjectChangeEventContextChoices,
 )
 from nautobot.extras.context_managers import change_logging, JobHookChangeContext, web_request_context
-from nautobot.extras.jobs import get_job, get_jobs
+from nautobot.extras.jobs import BaseJob, get_job, get_jobs
+from nautobot.extras.models import Job, JobQueue
+from nautobot.extras.models.jobs import JobLogEntry
 
 
 class JobTest(TestCase):
@@ -45,6 +47,11 @@ class JobTest(TestCase):
     Test job features that don't require a transaction test case.
     """
 
+    def test_as_form_no_job_model(self):
+        """Job.as_form() test with no corresponding job_model (https://github.com/nautobot/nautobot/issues/6773)."""
+        form = BaseJob.as_form()
+        self.assertSequenceEqual(list(form.fields.keys()), ["_job_queue", "_profile"])
+
     def test_field_default(self):
         """
         Job test with field that is a default value that is falsey.
@@ -53,7 +60,7 @@ class JobTest(TestCase):
         module = "field_default"
         name = "TestFieldDefault"
         job_class = get_job(f"{module}.{name}")
-        form = job_class().as_form()
+        form = job_class.as_form()
 
         self.assertInHTML(
             """<tr><th><label for="id_var_int">Var int:</label></th><td>
@@ -72,7 +79,7 @@ class JobTest(TestCase):
         module = "field_order"
         name = "TestFieldOrder"
         job_class = get_job(f"{module}.{name}")
-        form = job_class().as_form()
+        form = job_class.as_form()
         self.assertSequenceEqual(list(form.fields.keys()), ["var1", "var2", "var23", "_job_queue", "_profile"])
 
     def test_no_field_order(self):
@@ -82,7 +89,7 @@ class JobTest(TestCase):
         module = "no_field_order"
         name = "TestNoFieldOrder"
         job_class = get_job(f"{module}.{name}")
-        form = job_class().as_form()
+        form = job_class.as_form()
         self.assertSequenceEqual(list(form.fields.keys()), ["var23", "var2", "_job_queue", "_profile"])
 
     def test_no_field_order_inherited_variable(self):
@@ -92,7 +99,7 @@ class JobTest(TestCase):
         module = "no_field_order"
         name = "TestDefaultFieldOrderWithInheritance"
         job_class = get_job(f"{module}.{name}")
-        form = job_class().as_form()
+        form = job_class.as_form()
         self.assertSequenceEqual(
             list(form.fields.keys()),
             ["testvar1", "b_testvar2", "a_testvar3", "_job_queue", "_profile"],
@@ -107,14 +114,14 @@ class JobTest(TestCase):
         # not overridden on job model, initial form field value should match job class
         job_model.dryrun_default_override = False
         job_model.save()
-        form = job_class().as_form()
+        form = job_class.as_form()
         self.assertEqual(form.fields["dryrun"].initial, job_class.dryrun_default)
 
         # overridden on job model, initial form field value should match job model
         job_model.dryrun_default_override = True
         job_model.dryrun_default = not job_class.dryrun_default
         job_model.save()
-        form = job_class().as_form()
+        form = job_class.as_form()
         self.assertEqual(form.fields["dryrun"].initial, job_model.dryrun_default)
 
     def test_job_task_queues_setter(self):
@@ -143,7 +150,7 @@ class JobTest(TestCase):
             name="irrelevant", defaults={"queue_type": JobQueueTypeChoices.TYPE_CELERY}
         )
         job_model.job_queues.set([jq_1, jq_2])
-        form = job_class().as_form()
+        form = job_class.as_form()
         self.assertQuerySetEqual(
             form.fields["_job_queue"].queryset,
             models.JobQueue.objects.filter(jobs=job_model),
@@ -161,7 +168,7 @@ class JobTest(TestCase):
         self.assertTrue(job_model.supports_dryrun)
 
         module = "pass"
-        name = "TestPass"
+        name = "TestPassJob"
         job_class, job_model = get_job_class_and_model(module, name)
         self.assertFalse(job_class.supports_dryrun)
         self.assertFalse(job_model.supports_dryrun)
@@ -191,27 +198,31 @@ class JobTest(TestCase):
                 with override_settings(JOBS_ROOT=temp_dir):
                     # Create a new Job and make sure it's discovered correctly
                     with open(os.path.join(temp_dir, "my_jobs.py"), "w") as fd:
-                        fd.write("""\
+                        fd.write(
+                            """\
 from nautobot.apps.jobs import Job, register_jobs
 class MyJob(Job):
     def run(self):
         pass
 register_jobs(MyJob)
-""")
+"""
+                        )
                     jobs_data = get_jobs(reload=True)
                     self.assertIn("my_jobs.MyJob", jobs_data.keys())
                     self.assertIsNotNone(get_job("my_jobs.MyJob"))
                     # Also make sure some representative previous JOBS_ROOT jobs aren't still around:
                     self.assertNotIn("dry_run.TestDryRun", jobs_data.keys())
-                    self.assertNotIn("pass.TestPass", jobs_data.keys())
+                    self.assertNotIn("pass.TestPassJob", jobs_data.keys())
 
                     # Create a second Job in the same module
                     with open(os.path.join(temp_dir, "my_jobs.py"), "a") as fd:
-                        fd.write("""
+                        fd.write(
+                            """
 class MyOtherJob(MyJob):
     pass
 register_jobs(MyOtherJob)
-""")
+"""
+                        )
                     jobs_data = get_jobs(reload=True)
                     self.assertIn("my_jobs.MyJob", jobs_data.keys())
                     self.assertIsNotNone(get_job("my_jobs.MyJob"))
@@ -220,14 +231,16 @@ register_jobs(MyOtherJob)
 
                     # Create a third Job in another module
                     with open(os.path.join(temp_dir, "their_jobs.py"), "w") as fd:
-                        fd.write("""
+                        fd.write(
+                            """
 from nautobot.apps.jobs import Job, register_jobs
 
 class MyJob(Job):
     def run(self):
         pass
 register_jobs(MyJob)
-""")
+"""
+                        )
                     jobs_data = get_jobs(reload=True)
                     self.assertIn("my_jobs.MyJob", jobs_data.keys())
                     self.assertIsNotNone(get_job("my_jobs.MyJob"))
@@ -249,14 +262,16 @@ register_jobs(MyJob)
 
                     # Create a module with an inauspicious name
                     with open(os.path.join(temp_dir, "traceback.py"), "w") as fd:
-                        fd.write("""
+                        fd.write(
+                            """
 from nautobot.apps.jobs import Job, register_jobs
 
 class BadJob(Job):
     def run(self):
         raise RuntimeError("You ran a bad job!")
 register_jobs(BadJob)
-""")
+"""
+                        )
                     jobs_data = get_jobs(reload=True)
                     self.assertIn("my_jobs.MyJob", jobs_data.keys())
                     self.assertIsNotNone(get_job("my_jobs.MyJob"))
@@ -288,6 +303,105 @@ class JobTransactionTest(TransactionTestCase):
         self.request.id = uuid.uuid4()
         self.request.user = self.user
 
+    def test_bulk_delete_system_jobs_fail(self):
+        system_job_queryset = Job.objects.filter(module_name__startswith="nautobot.")
+        pk_list = [str(pk) for pk in system_job_queryset.values_list("pk", flat=True)[:3]]
+        initial_count = Job.objects.all().count()
+        self.add_permissions("extras.delete_job")
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=ContentType.objects.get_for_model(Job).id,
+            delete_all=False,
+            filter_query_params={},
+            pk_list=pk_list,
+            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.assertIn(
+            f"Unable to delete Job {system_job_queryset.first()}. System Job cannot be deleted", error_log.message
+        )
+        self.assertEqual(initial_count, Job.objects.all().count())
+
+    def test_job_bulk_edit_default_queue_stays_default_after_one_field_update(self):
+        self.add_permissions("extras.change_job", "extras.view_job")
+        job_class_to_test = "TestPassJob"
+        job_description = "default job queue test"
+        job_to_test = Job.objects.get(job_class_name=job_class_to_test)
+        queryset = Job.objects.filter(installed=True, hidden=False, job_class_name=job_class_to_test)
+        default_job_queue = job_to_test.default_job_queue
+        pk_list = list(queryset.values_list("pk", flat=True))
+
+        job_ct = ContentType.objects.get_for_model(Job)
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=job_ct.id,
+            edit_all=False,
+            filter_query_params={},
+            form_data={
+                "pk": pk_list,
+                "description": job_description,
+            },
+            username=self.user.username,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertEqual(Job.objects.filter(description=job_description).count(), queryset.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()
+        )
+        instance = Job.objects.get(job_class_name=job_class_to_test)
+        self.assertEqual(instance.description, job_description)
+        self.assertEqual(instance.default_job_queue, default_job_queue)
+
+    def test_job_bulk_edit_preserve_job_queues_after_one_field_update(self):
+        self.add_permissions("extras.change_job", "extras.view_job")
+        job_class_to_test = "TestPassJob"
+        job_description = "job queues test"
+        job_to_test = Job.objects.get(job_class_name=job_class_to_test)
+
+        # Simulate 3 job queues set
+        job_queues = JobQueue.objects.all()[:3]
+        job_to_test.job_queues.set(job_queues)
+        job_to_test.job_queues.add(job_to_test.default_job_queue)
+        job_to_test.job_queues_override = True
+        job_to_test.save()
+
+        expected_job_queues = list(job_to_test.job_queues.values_list("pk", flat=True))
+
+        queryset = Job.objects.filter(installed=True, hidden=False, job_class_name=job_class_to_test)
+        pk_list = list(queryset.values_list("pk", flat=True))
+
+        job_ct = ContentType.objects.get_for_model(Job)
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=job_ct.id,
+            edit_all=False,
+            filter_query_params={},
+            form_data={
+                "pk": pk_list,
+                "description": job_description,
+            },
+            username=self.user.username,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertEqual(Job.objects.filter(description=job_description).count(), queryset.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()
+        )
+
+        instance = Job.objects.get(job_class_name=job_class_to_test)
+        self.assertEqual(instance.description, job_description)
+        self.assertQuerySetEqual(instance.job_queues.all(), JobQueue.objects.filter(pk__in=expected_job_queues))
+
     def test_job_hard_time_limit_less_than_soft_time_limit(self):
         """
         Job test which produces a warning log message because the time_limit is less than the soft_time_limit.
@@ -310,7 +424,7 @@ class JobTransactionTest(TransactionTestCase):
         Job test with pass result.
         """
         module = "pass"
-        name = "TestPass"
+        name = "TestPassJob"
         job_result = create_job_result_and_run_job(module, name)
         self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
         self.assertEqual(job_result.result, True)
@@ -344,7 +458,7 @@ class JobTransactionTest(TransactionTestCase):
         Job test with fail result.
         """
         module = "fail"
-        name = "TestFail"
+        name = "TestFailJob"
         job_result = create_job_result_and_run_job(module, name)
         self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
         logs = job_result.job_log_entries
@@ -467,7 +581,7 @@ class JobTransactionTest(TransactionTestCase):
             "ipv6_with_mask": "2001:db8::1/64",
             "ipv6_network": "2001:db8::/64",
         }
-        form = job_class().as_form(form_data)
+        form = job_class.as_form(form_data)
         self.assertTrue(form.is_valid())
 
         # Prepare the job data
@@ -579,7 +693,7 @@ class JobTransactionTest(TransactionTestCase):
         Job test to see if the latest_result property is indeed returning the most recent job result
         """
         module = "pass"
-        name = "TestPass"
+        name = "TestPassJob"
         job_result_1 = create_job_result_and_run_job(module, name)
         self.assertEqual(job_result_1.status, JobResultStatusChoices.STATUS_SUCCESS)
         job_result_2 = create_job_result_and_run_job(module, name)
@@ -606,6 +720,38 @@ class JobTransactionTest(TransactionTestCase):
         self.assertTrue(profiling_result.exists())
         profiling_result.unlink()
 
+    def test_job_singleton(self):
+        module = "singleton"
+        name = "TestSingletonJob"
+
+        job_class, _ = get_job_class_and_model(module, name, "local")
+        self.assertTrue(job_class.is_singleton)
+        cache.set(job_class.singleton_cache_key, 1)
+        failed_job_result = create_job_result_and_run_job(module, name)
+
+        self.assertEqual(
+            failed_job_result.status, JobResultStatusChoices.STATUS_FAILURE, msg="Duplicate singleton job didn't error."
+        )
+        self.assertIsNone(cache.get(job_class.singleton_cache_key, None))
+
+    def test_job_ignore_singleton(self):
+        module = "singleton"
+        name = "TestSingletonJob"
+
+        job_class, _ = get_job_class_and_model(module, name, "local")
+        self.assertTrue(job_class.is_singleton)
+        cache.set(job_class.singleton_cache_key, 1)
+        passed_job_result = create_job_result_and_run_job(
+            module, name, celery_kwargs={"nautobot_job_ignore_singleton_lock": True}
+        )
+
+        self.assertEqual(
+            passed_job_result.status,
+            JobResultStatusChoices.STATUS_SUCCESS,
+            msg="Duplicate singleton job didn't succeed with nautobot_job_ignore_singleton_lock=True.",
+        )
+        self.assertIsNone(cache.get(job_class.singleton_cache_key, None))
+
     @mock.patch("nautobot.extras.context_managers.enqueue_webhooks")
     def test_job_fires_webhooks(self, mock_enqueue_webhooks):
         module = "atomic_transaction"
@@ -645,7 +791,7 @@ class JobFileUploadTest(TransactionTestCase):
 
         # Serialize the file to FileProxy
         data = {"file": self.test_file}
-        form = job_class().as_form(files=data)
+        form = job_class.as_form(files=data)
         self.assertTrue(form.is_valid())
         serialized_data = job_class.serialize_data(form.cleaned_data)
 
@@ -675,7 +821,7 @@ class JobFileUploadTest(TransactionTestCase):
 
         # Serialize the file to FileProxy
         data = {"file": self.test_file}
-        form = job_class().as_form(files=data)
+        form = job_class.as_form(files=data)
         self.assertTrue(form.is_valid())
         serialized_data = job_class.serialize_data(form.cleaned_data)
 
@@ -794,7 +940,7 @@ class RunJobManagementCommandTest(TransactionTestCase):
     def test_runjob_nochange_successful(self):
         """Basic success-path test for Jobs that don't modify the Nautobot database."""
         module = "pass"
-        name = "TestPass"
+        name = "TestPassJob"
         _job_class, job_model = get_job_class_and_model(module, name)
 
         out, err = self.run_command("--local", "--no-color", "--username", self.user.username, job_model.class_path)
@@ -880,7 +1026,7 @@ class JobButtonReceiverTest(TestCase):
         module = "job_button_receiver"
         name = "TestJobButtonReceiverSimple"
         job_class, _job_model = get_job_class_and_model(module, name)
-        form = job_class().as_form()
+        form = job_class.as_form()
         self.assertSequenceEqual(list(form.fields.keys()), ["object_pk", "object_model_name", "_job_queue", "_profile"])
 
     def test_hidden(self):
@@ -892,7 +1038,7 @@ class JobButtonReceiverTest(TestCase):
     def test_is_job_button(self):
         with self.subTest(expected=False):
             module = "pass"
-            name = "TestPass"
+            name = "TestPassJob"
             _job_class, job_model = get_job_class_and_model(module, name)
             self.assertFalse(job_model.is_job_button_receiver)
 
@@ -943,7 +1089,7 @@ class JobHookReceiverTest(TestCase):
         module = "job_hook_receiver"
         name = "TestJobHookReceiverLog"
         job_class, _job_model = get_job_class_and_model(module, name)
-        form = job_class().as_form()
+        form = job_class.as_form()
         self.assertSequenceEqual(list(form.fields.keys()), ["object_change", "_job_queue", "_profile"])
 
     def test_hidden(self):
@@ -955,7 +1101,7 @@ class JobHookReceiverTest(TestCase):
     def test_is_job_hook(self):
         with self.subTest(expected=False):
             module = "pass"
-            name = "TestPass"
+            name = "TestPassJob"
             _job_class, job_model = get_job_class_and_model(module, name)
             self.assertFalse(job_model.is_job_hook_receiver)
 
@@ -1116,7 +1262,7 @@ class RemoveScheduledJobManagementCommandTestCase(TestCase):
         for i in range(1, 7):
             models.ScheduledJob.objects.create(
                 name=f"test{i}",
-                task="pass.TestPass",
+                task="pass.TestPassJob",
                 interval=JobExecutionType.TYPE_FUTURE,
                 user=self.user,
                 start_time=timezone.now() - datetime.timedelta(days=i * 30),
@@ -1125,7 +1271,7 @@ class RemoveScheduledJobManagementCommandTestCase(TestCase):
 
         models.ScheduledJob.objects.create(
             name="test7",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             interval=JobExecutionType.TYPE_DAILY,
             user=self.user,
             start_time=timezone.now() - datetime.timedelta(days=180),
@@ -1153,7 +1299,7 @@ class ScheduledJobIntervalTestCase(TestCase):
         start_time = timezone.now() + datetime.timedelta(days=6)
         scheduled_job = models.ScheduledJob.objects.create(
             name="weekly_interval",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             interval=JobExecutionType.TYPE_WEEKLY,
             user=self.user,
             start_time=start_time,