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

nautobot/extras/test_jobs/fail.py

@@ -62,6 +62,20 @@ class TestFailJob(Job):
         logger.info("after_return() was called as expected")
 
 
+class TestFailInBeforeStart(TestFailJob):
+    """
+    Job that raises an exception in before_start().
+    """
+
+    def before_start(self, task_id, args, kwargs):
+        super().before_start(task_id, args, kwargs)
+        logger.info("I'm a test job that fails!")
+        raise RunJobTaskFailed("Setup failure")
+
+    def run(self):
+        raise RuntimeError("run() was unexpectedly called after a failure in before_start()")
+
+
 class TestFailWithSanitization(Job):
     """
     Job with fail result that should be sanitized.
@@ -91,4 +105,64 @@ class TestFailWithSanitization(Job):
         raise exc
 
 
-register_jobs(TestFailJob, TestFailWithSanitization)
+class TestFailCleanly(TestFailJob):
+    """
+    Job that fails "cleanly" through self.fail() instead of raising an exception.
+    """
+
+    def run(self):  # pylint: disable=arguments-differ
+        logger.info("I'm a test job that fails!")
+        self.fail("Failure")
+        return "We failed"
+
+    def on_failure(self, exc, task_id, args, kwargs, einfo):
+        if exc != "We failed":
+            raise RuntimeError(f"Expected exc to be the message returned from run(), but it was {exc!r}")
+        if task_id != self.request.id:  # pylint: disable=no-member
+            raise RuntimeError(f"Expected task_id {task_id} to equal self.request.id {self.request.id}")  # pylint: disable=no-member
+        if args:
+            raise RuntimeError(f"Expected args to be empty, but it was {args!r}")
+        if kwargs:
+            raise RuntimeError(f"Expected kwargs to be empty, but it was {kwargs!r}")
+        if einfo is not None:
+            raise RuntimeError(f"Expected einfo to be None, but it was {einfo!r}")
+        logger.info("on_failure() was called as expected")
+
+    def after_return(self, status, retval, task_id, args, kwargs, einfo):
+        if status is not JobResultStatusChoices.STATUS_FAILURE:
+            raise RuntimeError(f"Expected status to be {JobResultStatusChoices.STATUS_FAILURE}, but it was {status!r}")
+        if retval != "We failed":
+            raise RuntimeError(f"Expected retval to be the message returned from run(), but it was {retval!r}")
+        if task_id != self.request.id:  # pylint: disable=no-member
+            raise RuntimeError(f"Expected task_id {task_id} to equal self.request.id {self.request.id}")  # pylint: disable=no-member
+        if args:
+            raise RuntimeError(f"Expected args to be empty, but it was {args!r}")
+        if kwargs:
+            raise RuntimeError(f"Expected kwargs to be empty, but it was {kwargs!r}")
+        if einfo is not None:
+            raise RuntimeError(f"Expected einfo to be None, but it was {einfo!r}")
+        logger.info("after_return() was called as expected")
+
+
+class TestFailCleanlyInBeforeStart(TestFailCleanly):
+    """
+    Job that fails "cleanly" during before_start() through self.fail() instead of raising an exception.
+    """
+
+    def before_start(self, task_id, args, kwargs):
+        super().before_start(task_id, args, kwargs)
+        logger.info("I'm a test job that fails!")
+        self.fail("We failed")
+        return "We failed"
+
+    def run(self):
+        raise RuntimeError("run() was unexpectedly called after a failure in before_start()")
+
+
+register_jobs(
+    TestFailJob,
+    TestFailInBeforeStart,
+    TestFailWithSanitization,
+    TestFailCleanly,
+    TestFailCleanlyInBeforeStart,
+)

nautobot/extras/tests/test_api.py

@@ -1917,7 +1917,7 @@ class JobTest(
         mock_get_worker_count.return_value = 1
         self.add_permissions("extras.run_job")
 
-        job_model = Job.objects.get(job_class_name="ExampleJob")
+        job_model = Job.objects.get(job_class_name="TestHasSensitiveVariables")
         job_model.enabled = True
         job_model.validated_save()
 

nautobot/extras/tests/test_datasources.py

@@ -238,11 +238,7 @@ class GitTest(TransactionTestCase):
                     repository=self.repo.pk,
                 )
 
-                self.assertEqual(
-                    job_result.status,
-                    JobResultStatusChoices.STATUS_FAILURE,
-                    (job_result.result, list(job_result.job_log_entries.values_list("message", "log_object"))),
-                )
+                self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
                 self.repo.refresh_from_db()
 
                 log_entries = JobLogEntry.objects.filter(job_result=job_result)
@@ -308,11 +304,7 @@ class GitTest(TransactionTestCase):
                     repository=self.repo.pk,
                 )
 
-                self.assertEqual(
-                    job_result.status,
-                    JobResultStatusChoices.STATUS_SUCCESS,
-                    (job_result.traceback, list(job_result.job_log_entries.values_list("message", flat=True))),
-                )
+                self.assertJobResultStatus(job_result)
                 self.repo.refresh_from_db()
                 MockGitRepo.assert_called_with(
                     os.path.join(tempdir, self.repo.slug),
@@ -331,11 +323,7 @@ class GitTest(TransactionTestCase):
                 job_model = GitRepositorySync().job_model
                 job_result = run_job_for_testing(job=job_model, repository=self.repo.pk)
                 job_result.refresh_from_db()
-                self.assertEqual(
-                    job_result.status,
-                    JobResultStatusChoices.STATUS_SUCCESS,
-                    (job_result.traceback, list(job_result.job_log_entries.values_list("message", flat=True))),
-                )
+                self.assertJobResultStatus(job_result)
 
                 # Make sure explicit ConfigContext was successfully loaded from file
                 self.assert_explicit_config_context_exists("Frobozz 1000 NTP servers")
@@ -383,11 +371,7 @@ class GitTest(TransactionTestCase):
                 # Run the Git operation and refresh the object from the DB
                 job_result = run_job_for_testing(job=job_model, repository=self.repo.pk)
                 job_result.refresh_from_db()
-                self.assertEqual(
-                    job_result.status,
-                    JobResultStatusChoices.STATUS_SUCCESS,
-                    (job_result.traceback, list(job_result.job_log_entries.values_list("message", flat=True))),
-                )
+                self.assertJobResultStatus(job_result)
 
                 # Verify that objects have been removed from the database
                 self.assertEqual(
@@ -442,11 +426,7 @@ class GitTest(TransactionTestCase):
                 )
                 job_result.refresh_from_db()
 
-                self.assertEqual(
-                    job_result.status,
-                    JobResultStatusChoices.STATUS_FAILURE,
-                    job_result.result,
-                )
+                self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
 
                 # Due to transaction rollback on failure, the database should still/again match the pre-sync state, of
                 # no records owned by the repository.
@@ -547,11 +527,7 @@ class GitTest(TransactionTestCase):
                 )
                 job_result.refresh_from_db()
 
-                self.assertEqual(
-                    job_result.status,
-                    JobResultStatusChoices.STATUS_SUCCESS,
-                    (job_result.traceback, list(job_result.job_log_entries.values_list("message", flat=True))),
-                )
+                self.assertJobResultStatus(job_result)
 
                 # Make sure ConfigContext was successfully loaded from file
                 config_context = ConfigContext.objects.get(
@@ -591,15 +567,7 @@ class GitTest(TransactionTestCase):
                     delete_job_result = JobResult.objects.filter(name=repo_name).first()
                     # Make sure we didn't get the wrong JobResult
                     self.assertNotEqual(job_result, delete_job_result)
-                    self.assertEqual(
-                        delete_job_result.status,
-                        JobResultStatusChoices.STATUS_SUCCESS,
-                        (
-                            delete_job_result,
-                            delete_job_result.traceback,
-                            list(delete_job_result.job_log_entries.values_list("message", flat=True)),
-                        ),
-                    )
+                    self.assertJobResultStatus(delete_job_result)
 
                 with self.assertRaises(ConfigContext.DoesNotExist):
                     ConfigContext.objects.get(
@@ -637,11 +605,7 @@ class GitTest(TransactionTestCase):
                 job_model = GitRepositorySync().job_model
                 job_result = run_job_for_testing(job=job_model, repository=self.repo.pk)
                 job_result.refresh_from_db()
-                self.assertEqual(
-                    job_result.status,
-                    JobResultStatusChoices.STATUS_SUCCESS,
-                    (job_result.traceback, list(job_result.job_log_entries.values_list("message", flat=True))),
-                )
+                self.assertJobResultStatus(job_result)
 
                 self.assert_explicit_config_context_exists("Frobozz 1000 NTP servers")
                 self.assert_implicit_config_context_exists("Location context")
@@ -673,11 +637,7 @@ class GitTest(TransactionTestCase):
                 # Resync, attempting and failing to update to the new commit
                 job_result = run_job_for_testing(job=job_model, repository=self.repo.pk)
                 job_result.refresh_from_db()
-                self.assertEqual(
-                    job_result.status,
-                    JobResultStatusChoices.STATUS_FAILURE,
-                    job_result.result,
-                )
+                self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
                 log_entries = JobLogEntry.objects.filter(job_result=job_result)
 
                 # Assert database changes were rolled back
@@ -718,11 +678,7 @@ class GitTest(TransactionTestCase):
                 )
                 job_result.refresh_from_db()
 
-                self.assertEqual(
-                    job_result.status,
-                    JobResultStatusChoices.STATUS_SUCCESS,
-                    (job_result.traceback, list(job_result.job_log_entries.values_list("message", flat=True))),
-                )
+                self.assertJobResultStatus(job_result)
 
                 log_entries = JobLogEntry.objects.filter(job_result=job_result)
 
@@ -798,3 +754,57 @@ class GitTest(TransactionTestCase):
             "provides contents overlapping with this repository.",
             str(cm.exception),
         )
+
+    @mock.patch("nautobot.extras.models.datasources.GitRepo")
+    def test_clone_to_directory_with_secrets(self, MockGitRepo):
+        """
+        The clone_to_directory method should correctly make use of secrets.
+        """
+        with tempfile.TemporaryDirectory() as tempdir:
+            # Prepare secrets values
+            with open(os.path.join(tempdir, "username.txt"), "wt") as handle:
+                handle.write("núñez")
+
+            with open(os.path.join(tempdir, "token.txt"), "wt") as handle:
+                handle.write("1:3@/?=ab@")
+
+            # Create secrets and assign
+            username_secret = Secret.objects.create(
+                name="Git Username",
+                provider="text-file",
+                parameters={"path": os.path.join(tempdir, "username.txt")},
+            )
+            token_secret = Secret.objects.create(
+                name="Git Token",
+                provider="text-file",
+                parameters={"path": os.path.join(tempdir, "token.txt")},
+            )
+            secrets_group = SecretsGroup.objects.create(name="Git Credentials")
+            SecretsGroupAssociation.objects.create(
+                secret=username_secret,
+                secrets_group=secrets_group,
+                access_type=SecretsGroupAccessTypeChoices.TYPE_HTTP,
+                secret_type=SecretsGroupSecretTypeChoices.TYPE_USERNAME,
+            )
+            SecretsGroupAssociation.objects.create(
+                secret=token_secret,
+                secrets_group=secrets_group,
+                access_type=SecretsGroupAccessTypeChoices.TYPE_HTTP,
+                secret_type=SecretsGroupSecretTypeChoices.TYPE_TOKEN,
+            )
+
+            # Configure GitRepository model
+            self.repo.secrets_group = secrets_group
+            self.repo.remote_url = "http://localhost/git.git"
+            self.repo.save()
+
+            # Try to clone it
+            self.repo.clone_to_directory(tempdir, "main")
+
+            # Assert that GitRepo was called with proper args
+            args, kwargs = MockGitRepo.call_args
+            path, from_url = args
+            self.assertTrue(path.startswith(os.path.join(tempdir, self.repo.slug)))
+            self.assertEqual(from_url, "http://n%C3%BA%C3%B1ez:1%3A3%40%2F%3F%3Dab%40@localhost/git.git")
+            self.assertEqual(kwargs["depth"], 0)
+            self.assertEqual(kwargs["branch"], "main")

nautobot/extras/tests/test_jobs.py

@@ -317,7 +317,7 @@ class JobTransactionTest(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(
             f"Unable to delete Job {system_job_queryset.first()}. System Job cannot be deleted", error_log.message
@@ -346,7 +346,7 @@ class JobTransactionTest(TransactionTestCase):
             },
             username=self.user.username,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         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()
@@ -389,7 +389,7 @@ class JobTransactionTest(TransactionTestCase):
             },
             username=self.user.username,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         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()
@@ -426,7 +426,7 @@ class JobTransactionTest(TransactionTestCase):
         module = "pass"
         name = "TestPassJob"
         job_result = create_job_result_and_run_job(module, name)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertEqual(job_result.result, True)
         logs = job_result.job_log_entries
         self.assertGreater(logs.count(), 0)
@@ -449,7 +449,7 @@ class JobTransactionTest(TransactionTestCase):
         name = "TestHasSensitiveVariables"
         # This function create_job_result_and_run_job and the subsequent functions' arguments are very messy
         job_result = create_job_result_and_run_job(module, name, "local", 1, 2, "3", kwarg_1=1, kwarg_2="2")
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertEqual(job_result.task_args, [])
         self.assertEqual(job_result.task_kwargs, {})
 
@@ -458,21 +458,22 @@ class JobTransactionTest(TransactionTestCase):
         Job test with fail result.
         """
         module = "fail"
-        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
-        self.assertGreater(logs.count(), 0)
-        try:
-            logs.get(message="before_start() was called as expected")
-            logs.get(message="I'm a test job that fails!")
-            logs.get(message="on_failure() was called as expected")
-            logs.get(message="after_return() was called as expected")
-        except models.JobLogEntry.DoesNotExist:
-            for log in logs.all():
-                print(log.message)
-            print(job_result.traceback)
-            raise
+        for name in ["TestFailJob", "TestFailInBeforeStart", "TestFailCleanly", "TestFailCleanlyInBeforeStart"]:
+            with self.subTest(job=name):
+                job_result = create_job_result_and_run_job(module, name)
+                self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
+                logs = job_result.job_log_entries
+                self.assertGreater(logs.count(), 0)
+                try:
+                    logs.get(message="before_start() was called as expected")
+                    logs.get(message="I'm a test job that fails!")
+                    logs.get(message="on_failure() was called as expected")
+                    logs.get(message="after_return() was called as expected")
+                except models.JobLogEntry.DoesNotExist:
+                    for log in logs.all():
+                        print(log.message)
+                    print(job_result.traceback)
+                    raise
 
     def test_job_fail_with_sanitization(self):
         """
@@ -482,7 +483,7 @@ class JobTransactionTest(TransactionTestCase):
         name = "TestFailWithSanitization"
         job_result = create_job_result_and_run_job(module, name)
         json_result = json.dumps(job_result.result)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         self.assertIn("(redacted)@github.com", json_result)
         self.assertNotIn("abc123@github.com", json_result)
         self.assertIn("(redacted)@github.com", job_result.traceback)
@@ -495,7 +496,7 @@ class JobTransactionTest(TransactionTestCase):
         module = "atomic_transaction"
         name = "TestAtomicDecorator"
         job_result = create_job_result_and_run_job(module, name)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         # Ensure DB transaction was not aborted
         self.assertTrue(models.Status.objects.filter(name="Test database atomic rollback 1").exists())
         # Ensure the correct job log messages were saved
@@ -513,7 +514,7 @@ class JobTransactionTest(TransactionTestCase):
         module = "atomic_transaction"
         name = "TestAtomicContextManager"
         job_result = create_job_result_and_run_job(module, name)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         # Ensure DB transaction was not aborted
         self.assertTrue(models.Status.objects.filter(name="Test database atomic rollback 2").exists())
         # Ensure the correct job log messages were saved
@@ -530,8 +531,8 @@ class JobTransactionTest(TransactionTestCase):
         """
         module = "atomic_transaction"
         name = "TestAtomicDecorator"
-        job_result = create_job_result_and_run_job(module, name, fail=True)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        job_result = create_job_result_and_run_job(module, name, should_fail=True)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         # Ensure DB transaction was aborted
         self.assertFalse(models.Status.objects.filter(name="Test database atomic rollback 1").exists())
         # Ensure the correct job log messages were saved
@@ -547,8 +548,8 @@ class JobTransactionTest(TransactionTestCase):
         """
         module = "atomic_transaction"
         name = "TestAtomicContextManager"
-        job_result = create_job_result_and_run_job(module, name, fail=True)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        job_result = create_job_result_and_run_job(module, name, should_fail=True)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         # Ensure DB transaction was aborted
         self.assertFalse(models.Status.objects.filter(name="Test database atomic rollback 2").exists())
         # Ensure the correct job log messages were saved
@@ -596,7 +597,7 @@ class JobTransactionTest(TransactionTestCase):
         job_result_data = json.loads(log_info.log_object) if log_info.log_object else None
 
         # Assert stuff
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertEqual(form_data, job_result_data)
 
     @override_settings(
@@ -651,7 +652,7 @@ class JobTransactionTest(TransactionTestCase):
         ).first()
 
         # Assert stuff
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertEqual(info_log.log_object, "")
         self.assertEqual(info_log.message, f"Role: {role.name}")
         self.assertEqual(job_result.result, "Nice Roles!")
@@ -670,7 +671,7 @@ class JobTransactionTest(TransactionTestCase):
         ).first()
 
         # Assert stuff
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertEqual(info_log.log_object, "")
         self.assertEqual(info_log.message, "The Location if any that the user provided.")
         self.assertEqual(job_result.result, "Nice Location (or not)!")
@@ -685,7 +686,7 @@ class JobTransactionTest(TransactionTestCase):
         job_result = create_job_result_and_run_job(module, name, **data)
 
         # Assert stuff
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         self.assertIn("location is a required field", job_result.traceback)
 
     def test_job_latest_result_property(self):
@@ -695,9 +696,9 @@ class JobTransactionTest(TransactionTestCase):
         module = "pass"
         name = "TestPassJob"
         job_result_1 = create_job_result_and_run_job(module, name)
-        self.assertEqual(job_result_1.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result_1)
         job_result_2 = create_job_result_and_run_job(module, name)
-        self.assertEqual(job_result_2.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result_2)
         _job_class, job_model = get_job_class_and_model(module, name)
         self.assertGreaterEqual(job_model.job_results.count(), 2)
         latest_job_result = job_model.latest_result
@@ -710,11 +711,7 @@ class JobTransactionTest(TransactionTestCase):
         # The job itself contains the 'assert' by loading the resulting profiling file from the workers filesystem
         job_result = create_job_result_and_run_job(module, name, profile=True)
 
-        self.assertEqual(
-            job_result.status,
-            JobResultStatusChoices.STATUS_SUCCESS,
-            msg="Profiling test job errored, this indicates that either no profiling file was created or it is malformed.",
-        )
+        self.assertJobResultStatus(job_result)
 
         profiling_result = Path(f"{tempfile.gettempdir()}/nautobot-jobresult-{job_result.id}.pstats")
         self.assertTrue(profiling_result.exists())
@@ -727,12 +724,17 @@ class JobTransactionTest(TransactionTestCase):
         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)
+        try:
+            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))
+            self.assertEqual(
+                failed_job_result.status,
+                JobResultStatusChoices.STATUS_FAILURE,
+                msg="Duplicate singleton job didn't error.",
+            )
+        finally:
+            # Clean up after ourselves
+            cache.delete(job_class.singleton_cache_key)
 
     def test_job_ignore_singleton(self):
         module = "singleton"
@@ -741,16 +743,21 @@ class JobTransactionTest(TransactionTestCase):
         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}
-        )
+        try:
+            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))
+            self.assertEqual(
+                passed_job_result.status,
+                JobResultStatusChoices.STATUS_SUCCESS,
+                msg="Duplicate singleton job didn't succeed with nautobot_job_ignore_singleton_lock=True.",
+            )
+            # Singleton cache key should be cleared when the job completes
+            self.assertIsNone(cache.get(job_class.singleton_cache_key, None))
+        finally:
+            # Clean up after ourselves, just in case
+            cache.delete(job_class.singleton_cache_key)
 
     @mock.patch("nautobot.extras.context_managers.enqueue_webhooks")
     def test_job_fires_webhooks(self, mock_enqueue_webhooks):
@@ -762,7 +769,7 @@ class JobTransactionTest(TransactionTestCase):
         webhook.content_types.set([status_ct])
 
         job_result = create_job_result_and_run_job(module, name)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
 
         mock_enqueue_webhooks.assert_called_once()
 
@@ -865,7 +872,7 @@ class JobFileOutputTest(TransactionTestCase):
         data = {"lines": 3}
         job_result = create_job_result_and_run_job(module, name, **data)
 
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS, job_result.traceback)
+        self.assertJobResultStatus(job_result)
         # JobResult should have one attached file
         self.assertEqual(1, job_result.files.count())
         self.assertEqual(job_result.files.first().name, "output.txt")
@@ -896,7 +903,7 @@ class JobFileOutputTest(TransactionTestCase):
         # Exactly JOB_CREATE_FILE_MAX_SIZE bytes should be okay:
         with override_config(JOB_CREATE_FILE_MAX_SIZE=len("Hello world!\n")):
             job_result = create_job_result_and_run_job(module, name, **data)
-            self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS, job_result.traceback)
+            self.assertJobResultStatus(job_result)
             self.assertEqual(1, job_result.files.count())
             self.assertEqual(job_result.files.first().name, "output.txt")
             self.assertEqual(job_result.files.first().file.read().decode("utf-8"), "Hello World!\n")
@@ -904,7 +911,7 @@ class JobFileOutputTest(TransactionTestCase):
         # Even one byte over is too much:
         with override_config(JOB_CREATE_FILE_MAX_SIZE=len("Hello world!\n") - 1):
             job_result = create_job_result_and_run_job(module, name, **data)
-            self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+            self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
             self.assertIn("ValueError", job_result.traceback)
             self.assertEqual(0, job_result.files.count())
 
@@ -912,7 +919,7 @@ class JobFileOutputTest(TransactionTestCase):
         with override_config(JOB_CREATE_FILE_MAX_SIZE=10 << 20):
             with override_settings(JOB_CREATE_FILE_MAX_SIZE=len("Hello world!\n") - 1):
                 job_result = create_job_result_and_run_job(module, name, **data)
-                self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+                self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
                 self.assertIn("ValueError", job_result.traceback)
                 self.assertEqual(0, job_result.files.count())
 
@@ -945,7 +952,7 @@ class RunJobManagementCommandTest(TransactionTestCase):
 
         out, err = self.run_command("--local", "--no-color", "--username", self.user.username, job_model.class_path)
         self.assertIn(f"Running {job_model.class_path}...", out)
-        self.assertIn("run: 0 debug, 1 info, 0 warning, 0 error, 0 critical", out)
+        self.assertIn("run: 0 debug, 1 info, 0 success, 0 warning, 0 failure, 0 error, 0 critical", out)
         self.assertIn("info: Success", out)
         self.assertIn(f"{job_model.class_path}: SUCCESS", out)
         self.assertEqual("", err)
@@ -967,7 +974,7 @@ class RunJobManagementCommandTest(TransactionTestCase):
         out, err = self.run_command("--local", "--no-color", "--username", self.user.username, job_model.class_path)
         self.assertIn(f"Running {job_model.class_path}...", out)
         # Changed job to actually log data. Can't display empty results if no logs were created.
-        self.assertIn("run: 0 debug, 1 info, 0 warning, 0 error, 0 critical", out)
+        self.assertIn("run: 0 debug, 1 info, 0 success, 0 warning, 0 failure, 0 error, 0 critical", out)
         self.assertIn(f"{job_model.class_path}: SUCCESS", out)
         self.assertEqual("", err)
 
@@ -999,7 +1006,7 @@ class JobLocationCustomFieldTest(TransactionTestCase):
         job_result = create_job_result_and_run_job(module, name)
         job_result.refresh_from_db()
 
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
 
         # Test location with a value for custom_field
         location_1 = Location.objects.filter(name="Test Location One")
@@ -1077,7 +1084,7 @@ class JobButtonReceiverTransactionTest(TransactionTestCase):
         module = "job_button_receiver"
         name = "TestJobButtonReceiverFail"
         job_result = create_job_result_and_run_job(module, name, **self.data)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
 
 
 class JobHookReceiverTest(TestCase):
@@ -1149,7 +1156,7 @@ class JobHookReceiverTransactionTest(TransactionTestCase):
         module = "job_hook_receiver"
         name = "TestJobHookReceiverFail"
         job_result = create_job_result_and_run_job(module, name, **self.data)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
 
 
 class JobHookTest(TestCase):

nautobot/extras/tests/test_models.py

@@ -1367,7 +1367,7 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
     def setUpTestData(cls):
         # JobModel instances are automatically instantiated at startup, so we just need to look them up.
         cls.local_job = JobModel.objects.get(job_class_name="TestPassJob")
-        cls.job_containing_sensitive_variables = JobModel.objects.get(job_class_name="ExampleLoggingJob")
+        cls.job_containing_sensitive_variables = JobModel.objects.get(job_class_name="TestHasSensitiveVariables")
         cls.app_job = JobModel.objects.get(job_class_name="ExampleJob")
 
     def test_job_class(self):