nautobot 2.4.0b1__py3-none-any.whl → 2.4.1__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,

nautobot/extras/tests/test_models.py

@@ -1083,7 +1083,7 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
     @classmethod
     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="TestPass")
+        cls.local_job = JobModel.objects.get(job_class_name="TestPassJob")
         cls.job_containing_sensitive_variables = JobModel.objects.get(job_class_name="ExampleLoggingJob")
         cls.app_job = JobModel.objects.get(job_class_name="ExampleJob")
 
@@ -1095,7 +1095,7 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
         self.assertEqual(self.app_job.job_class, ExampleJob)
 
     def test_class_path(self):
-        self.assertEqual(self.local_job.class_path, "pass.TestPass")
+        self.assertEqual(self.local_job.class_path, "pass.TestPassJob")
         self.assertIsNotNone(self.local_job.job_class)
         self.assertEqual(self.local_job.class_path, self.local_job.job_class.class_path)
 
@@ -1832,11 +1832,11 @@ class ScheduledJobTest(ModelTestCases.BaseModelTestCase):
 
     def setUp(self):
         self.user = User.objects.create_user(username="scheduledjobuser")
-        self.job_model = JobModel.objects.get(name="TestPass")
+        self.job_model = JobModel.objects.get(name="TestPassJob")
 
         self.daily_utc_job = ScheduledJob.objects.create(
             name="Daily UTC Job",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             job_model=self.job_model,
             interval=JobExecutionType.TYPE_DAILY,
             start_time=datetime(year=2050, month=1, day=22, hour=17, minute=0, tzinfo=get_default_timezone()),
@@ -1844,7 +1844,7 @@ class ScheduledJobTest(ModelTestCases.BaseModelTestCase):
         )
         self.daily_est_job = ScheduledJob.objects.create(
             name="Daily EST Job",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             job_model=self.job_model,
             interval=JobExecutionType.TYPE_DAILY,
             start_time=datetime(year=2050, month=1, day=22, hour=17, minute=0, tzinfo=ZoneInfo("America/New_York")),
@@ -1859,7 +1859,7 @@ class ScheduledJobTest(ModelTestCases.BaseModelTestCase):
         )
         self.crontab_est_job = ScheduledJob.objects.create(
             name="Crontab EST Job",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             job_model=self.job_model,
             interval=JobExecutionType.TYPE_CUSTOM,
             start_time=datetime(year=2050, month=1, day=22, hour=17, minute=0, tzinfo=ZoneInfo("America/New_York")),
@@ -1868,7 +1868,7 @@ class ScheduledJobTest(ModelTestCases.BaseModelTestCase):
         )
         self.one_off_utc_job = ScheduledJob.objects.create(
             name="One-off UTC Job",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             job_model=self.job_model,
             interval=JobExecutionType.TYPE_FUTURE,
             start_time=datetime(year=2050, month=1, day=22, hour=0, minute=0, tzinfo=ZoneInfo("UTC")),
@@ -2015,7 +2015,7 @@ class ScheduledJobTest(ModelTestCases.BaseModelTestCase):
         """Test that TYPE_CUSTOM behavior around DST is as expected."""
         cronjob = ScheduledJob.objects.create(
             name="DST Aware Cronjob",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             job_model=self.job_model,
             enabled=False,
             interval=JobExecutionType.TYPE_CUSTOM,
@@ -2070,7 +2070,7 @@ class ScheduledJobTest(ModelTestCases.BaseModelTestCase):
         """Test the interaction of TYPE_DAILY around DST."""
         daily = ScheduledJob.objects.create(
             name="Daily Job",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             job_model=self.job_model,
             enabled=False,
             interval=JobExecutionType.TYPE_DAILY,
@@ -2146,6 +2146,12 @@ class ScheduledJobTest(ModelTestCases.BaseModelTestCase):
     #     entry = NautobotScheduleEntry(model=sj)
     #     scheduler = NautobotDatabaseScheduler(app=entry.app)
     #     scheduler.apply_async(entry=entry, producer=None, advance=False)
+    #     Check scheduled job runs correctly with no job queue
+    #     sj.job_queue = None
+    #     sj.save()
+    #     entry = NautobotScheduleEntry(model=sj)
+    #     scheduler = NautobotDatabaseScheduler(app=entry.app)
+    #     scheduler.apply_async(entry=entry, producer=None, advance=False)
 
 
 class SecretTest(ModelTestCases.BaseModelTestCase):
@@ -2638,7 +2644,7 @@ class JobLogEntryTest(TestCase):  # TODO: change to BaseModelTestCase
 
     def setUp(self):
         module = "pass"
-        name = "TestPass"
+        name = "TestPassJob"
         job_class = get_job(f"{module}.{name}")
 
         self.job_result = JobResult.objects.create(name=job_class.class_path, user=None)

nautobot/extras/tests/test_plugins.py

@@ -1,5 +1,6 @@
-from unittest import mock, skip, skipIf
+from unittest import mock, skip
 
+from django.apps import apps
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
@@ -21,6 +22,7 @@ from nautobot.extras.models import CustomField, Relationship, RelationshipAssoci
 from nautobot.extras.plugins.exceptions import PluginImproperlyConfigured
 from nautobot.extras.plugins.utils import load_plugin
 from nautobot.extras.plugins.validators import wrap_model_clean_methods
+from nautobot.extras.plugins.views import extract_app_data
 from nautobot.extras.registry import DatasourceContent, registry
 from nautobot.ipam.models import IPAddress, Namespace, Prefix
 from nautobot.tenancy.filters import TenantFilterSet
@@ -315,6 +317,61 @@ class AppListViewTest(TestCase):
         response_body = extract_page_body(response.content.decode(response.charset)).lower()
         self.assertIn("example app", response_body, msg=response_body)
 
+    def test_extract_app_data(self):
+        app_config = apps.get_app_config("example_app")
+        # Without a corresponding entry in marketplace_data
+        self.assertEqual(
+            extract_app_data(app_config, {"apps": []}),
+            {
+                "name": "Example Nautobot App",
+                "package": "example_app",
+                "app_label": "example_app",
+                "author": "Nautobot development team",
+                "author_email": "nautobot@example.com",
+                "headline": "For testing purposes only",
+                "description": "For testing purposes only",
+                "version": "1.0.0",
+                "home_url": "plugins:example_app:home",
+                "config_url": "plugins:example_app:config",
+                "docs_url": "plugins:example_app:docs",
+            },
+        )
+
+        # With a corresponding entry in marketplace_data
+        mock_marketplace_data = {
+            "apps": [
+                {
+                    "name": "Nautobot Example App",
+                    "use_cases": ["Example", "Development"],
+                    "requires": [],
+                    "docs": "https://example.com/docs/example_app/",
+                    "headline": "Demonstrate and test various parts of Nautobot App APIs and functionality.",
+                    "description": "An example of the kinds of things a Nautobot App can do, including ...",
+                    "package_name": "example_app",
+                    "author": "Network to Code (NTC)",
+                    "availability": "Open Source",
+                    "icon": "...",
+                },
+            ],
+        }
+        self.assertEqual(
+            extract_app_data(app_config, mock_marketplace_data),
+            {
+                "name": "Nautobot Example App",
+                "package": "example_app",
+                "app_label": "example_app",
+                "author": "Network to Code (NTC)",
+                "author_email": "nautobot@example.com",
+                "availability": "Open Source",
+                "headline": "Demonstrate and test various parts of Nautobot App APIs and functionality.",
+                "description": "An example of the kinds of things a Nautobot App can do, including ...",
+                "version": "1.0.0",
+                "home_url": "plugins:example_app:home",
+                "config_url": "plugins:example_app:config",
+                "docs_url": "plugins:example_app:docs",
+            },
+        )
+
 
 class PluginDetailViewTest(TestCase):
     def test_view_detail_anonymous(self):
@@ -800,10 +857,6 @@ class TestAppCoreViewOverrides(TestCase):
         )
 
 
-@skipIf(
-    "example_plugin" not in settings.PLUGINS,
-    "example_plugin not in settings.PLUGINS",
-)
 class PluginTemplateExtensionsTest(TestCase):
     """
     Test that registered TemplateExtensions inject content as expected
@@ -823,19 +876,19 @@ class PluginTemplateExtensionsTest(TestCase):
     def test_detail_view_buttons(self):
         response = self.client.get(reverse("dcim:location", kwargs={"pk": self.location.pk}))
         response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn("LOCATION CONTENT - BUTTONS", response_body, msg=response_body)
+        self.assertIn("APP INJECTED LOCATION CONTENT - BUTTONS", response_body, msg=response_body)
 
     def test_detail_view_left_page(self):
         response = self.client.get(reverse("dcim:location", kwargs={"pk": self.location.pk}))
         response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn("LOCATION CONTENT - LEFT PAGE", response_body, msg=response_body)
+        self.assertIn("App Injected Content - Left", response_body, msg=response_body)
 
     def test_detail_view_right_page(self):
         response = self.client.get(reverse("dcim:location", kwargs={"pk": self.location.pk}))
         response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn("LOCATION CONTENT - RIGHT PAGE", response_body, msg=response_body)
+        self.assertIn("App Injected Content - Right", response_body, msg=response_body)
 
     def test_detail_view_full_width_page(self):
         response = self.client.get(reverse("dcim:location", kwargs={"pk": self.location.pk}))
         response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn("LOCATION CONTENT - FULL WIDTH PAGE", response_body, msg=response_body)
+        self.assertIn("App Injected Content - Full Width", response_body, msg=response_body)