nautobot 2.3.0b1__py3-none-any.whl → 2.3.2__py3-none-any.whl

nautobot/extras/tests/test_models.py

@@ -14,8 +14,15 @@ from django.db.models import ProtectedError
 from django.db.utils import IntegrityError
 from django.test import override_settings
 from django.test.utils import isolate_apps
-from django.utils.timezone import now
+from django.utils.timezone import get_default_timezone, now
+from django_celery_beat.tzcrontab import TzAwareCrontab
 from jinja2.exceptions import TemplateAssertionError, TemplateSyntaxError
+import time_machine
+
+try:
+    from zoneinfo import ZoneInfo
+except ImportError:  # python 3.8
+    from backports.zoneinfo import ZoneInfo
 
 from nautobot.circuits.models import CircuitType
 from nautobot.core.choices import ColorChoices
@@ -30,6 +37,7 @@ from nautobot.dcim.models import (
     Platform,
 )
 from nautobot.extras.choices import (
+    JobExecutionType,
     JobResultStatusChoices,
     LogLevelChoices,
     MetadataTypeDataTypeChoices,
@@ -65,6 +73,7 @@ from nautobot.extras.models import (
     ObjectMetadata,
     Role,
     SavedView,
+    ScheduledJob,
     Secret,
     SecretsGroup,
     SecretsGroupAssociation,
@@ -1352,7 +1361,7 @@ class ObjectMetadataTest(ModelTestCases.BaseModelTestCase):
                 value="Invalid assigned object type",
                 scoped_fields=["status"],
                 assigned_object_type=ContentType.objects.get_for_model(IPAddress),
-                assigned_object_id=Contact.objects.first().pk,
+                assigned_object_id=Contact.objects.filter(associated_object_metadata__isnull=True).first().pk,
             )
             obj_metadata.validated_save()
 
@@ -1362,29 +1371,29 @@ class ObjectMetadataTest(ModelTestCases.BaseModelTestCase):
         )
         type_contact_team.content_types.add(ContentType.objects.get_for_model(Contact))
         type_contact_team.content_types.add(ContentType.objects.get_for_model(Team))
-        instance1 = ObjectMetadata.objects.create(
+        instance1 = ObjectMetadata(
             metadata_type=type_contact_team,
             contact=Contact.objects.first(),
             team=Team.objects.first(),
             scoped_fields=["address"],
             assigned_object_type=ContentType.objects.get_for_model(Contact),
-            assigned_object_id=Contact.objects.first().pk,
+            assigned_object_id=Contact.objects.filter(associated_object_metadata__isnull=True).first().pk,
         )
-        instance2 = ObjectMetadata.objects.create(
+        instance2 = ObjectMetadata(
             metadata_type=type_contact_team,
             contact=None,
             team=None,
             scoped_fields=["phone"],
             assigned_object_type=ContentType.objects.get_for_model(Contact),
-            assigned_object_id=Contact.objects.last().pk,
+            assigned_object_id=Contact.objects.filter(associated_object_metadata__isnull=True).last().pk,
         )
-        instance3 = ObjectMetadata.objects.create(
+        instance3 = ObjectMetadata(
             metadata_type=type_contact_team,
             contact=Contact.objects.first(),
             team=None,
             scoped_fields=["email"],
             assigned_object_type=ContentType.objects.get_for_model(Team),
-            assigned_object_id=Team.objects.first().pk,
+            assigned_object_id=Team.objects.filter(associated_object_metadata__isnull=True).first().pk,
         )
         with self.assertRaises(ValidationError):
             instance1.validated_save()
@@ -1407,7 +1416,7 @@ class ObjectMetadataTest(ModelTestCases.BaseModelTestCase):
             value="Some text value",
             scoped_fields=["status", "parent"],
             assigned_object_type=obj_type,
-            assigned_object_id=Location.objects.first().pk,
+            assigned_object_id=Location.objects.filter(associated_object_metadata__isnull=True).first().pk,
         )
         obj_metadata.save()
 
@@ -1440,7 +1449,7 @@ class ObjectMetadataTest(ModelTestCases.BaseModelTestCase):
             value=15,
             scoped_fields=["status", "parent"],
             assigned_object_type=obj_type,
-            assigned_object_id=Location.objects.first().pk,
+            assigned_object_id=Location.objects.filter(associated_object_metadata__isnull=True).first().pk,
         )
         obj_metadata.validated_save()
 
@@ -1484,7 +1493,7 @@ class ObjectMetadataTest(ModelTestCases.BaseModelTestCase):
             value=15.245,
             scoped_fields=["status", "parent"],
             assigned_object_type=obj_type,
-            assigned_object_id=Location.objects.first().pk,
+            assigned_object_id=Location.objects.filter(associated_object_metadata__isnull=True).first().pk,
         )
         obj_metadata.validated_save()
 
@@ -1525,7 +1534,7 @@ class ObjectMetadataTest(ModelTestCases.BaseModelTestCase):
             value=False,
             scoped_fields=["status", "parent"],
             assigned_object_type=obj_type,
-            assigned_object_id=Location.objects.first().pk,
+            assigned_object_id=Location.objects.filter(associated_object_metadata__isnull=True).first().pk,
         )
         obj_metadata.validated_save()
 
@@ -1559,7 +1568,7 @@ class ObjectMetadataTest(ModelTestCases.BaseModelTestCase):
             value="1994-01-01",
             scoped_fields=["status", "parent"],
             assigned_object_type=obj_type,
-            assigned_object_id=Location.objects.first().pk,
+            assigned_object_id=Location.objects.filter(associated_object_metadata__isnull=True).first().pk,
         )
         obj_metadata.validated_save()
 
@@ -1596,7 +1605,7 @@ class ObjectMetadataTest(ModelTestCases.BaseModelTestCase):
             value="2024-06-27T17:58:47-0500",
             scoped_fields=["status", "parent"],
             assigned_object_type=obj_type,
-            assigned_object_id=Location.objects.first().pk,
+            assigned_object_id=Location.objects.filter(associated_object_metadata__isnull=True).first().pk,
         )
         obj_metadata.validated_save()
 
@@ -1663,7 +1672,7 @@ class ObjectMetadataTest(ModelTestCases.BaseModelTestCase):
             value="Option A",
             scoped_fields=["status", "parent"],
             assigned_object_type=obj_type,
-            assigned_object_id=Location.objects.first().pk,
+            assigned_object_id=Location.objects.filter(associated_object_metadata__isnull=True).first().pk,
         )
         obj_metadata.validated_save()
 
@@ -1689,7 +1698,7 @@ class ObjectMetadataTest(ModelTestCases.BaseModelTestCase):
             value=["Option A"],
             scoped_fields=["status", "parent"],
             assigned_object_type=obj_type,
-            assigned_object_id=Location.objects.first().pk,
+            assigned_object_id=Location.objects.filter(associated_object_metadata__isnull=True).first().pk,
         )
         obj_metadata.validated_save()
 
@@ -1700,20 +1709,22 @@ class ObjectMetadataTest(ModelTestCases.BaseModelTestCase):
         self.assertIn(f"Invalid choice(s) ({invalid_options})", str(context.exception))
 
     def test_no_scoped_fields_overlap(self):
-        """Test that overlapping between scoped_fields of ObjectMetadata with the same metadata_type and the same assigned_object is not allowed"""
+        """
+        Test that overlapping scoped_fields of ObjectMetadata with same metadata_type/assigned_object is not allowed.
+        """
         ObjectMetadata.objects.create(
             metadata_type=MetadataType.objects.first(),
             contact=Contact.objects.first(),
             scoped_fields=["host", "mask_length", "type", "role", "status"],
             assigned_object_type=ContentType.objects.get_for_model(IPAddress),
-            assigned_object_id=IPAddress.objects.first().pk,
+            assigned_object_id=IPAddress.objects.filter(associated_object_metadata__isnull=True).first().pk,
         )
         instance2 = ObjectMetadata.objects.create(
             metadata_type=MetadataType.objects.first(),
             contact=Contact.objects.first(),
             scoped_fields=[],
             assigned_object_type=ContentType.objects.get_for_model(IPAddress),
-            assigned_object_id=IPAddress.objects.first().pk,
+            assigned_object_id=IPAddress.objects.filter(associated_object_metadata__isnull=True).first().pk,
         )
         with self.assertRaises(ValidationError):
             # try scope all fields
@@ -1788,6 +1799,295 @@ class SavedViewTest(ModelTestCases.BaseModelTestCase):
         self.assertEqual(self.ipaddress_global_sv.is_shared, True)
 
 
+@override_settings(TIME_ZONE="UTC")
+class ScheduledJobTest(ModelTestCases.BaseModelTestCase):
+    """Tests for the `ScheduledJob` model class."""
+
+    model = ScheduledJob
+
+    def setUp(self):
+        self.user = User.objects.create_user(username="scheduledjobuser")
+        self.job_model = JobModel.objects.get(name="TestPass")
+
+        self.daily_utc_job = ScheduledJob.objects.create(
+            name="Daily UTC Job",
+            task="pass.TestPass",
+            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()),
+            time_zone=get_default_timezone(),
+        )
+        self.daily_est_job = ScheduledJob.objects.create(
+            name="Daily EST Job",
+            task="pass.TestPass",
+            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")),
+            time_zone=ZoneInfo("America/New_York"),
+        )
+        self.crontab_utc_job = ScheduledJob.create_schedule(
+            job_model=self.job_model,
+            user=self.user,
+            name="Crontab UTC Job",
+            interval=JobExecutionType.TYPE_CUSTOM,
+            crontab="0 17 * * *",
+        )
+        self.crontab_est_job = ScheduledJob.objects.create(
+            name="Crontab EST Job",
+            task="pass.TestPass",
+            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")),
+            time_zone=ZoneInfo("America/New_York"),
+            crontab="0 17 * * *",
+        )
+        self.one_off_utc_job = ScheduledJob.objects.create(
+            name="One-off UTC Job",
+            task="pass.TestPass",
+            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")),
+            time_zone=ZoneInfo("UTC"),
+        )
+        self.one_off_est_job = ScheduledJob.create_schedule(
+            job_model=self.job_model,
+            user=self.user,
+            name="One-off EST Job",
+            interval=JobExecutionType.TYPE_FUTURE,
+            start_time=datetime(year=2050, month=1, day=22, hour=0, minute=0, tzinfo=ZoneInfo("America/New_York")),
+        )
+
+    def test_schedule(self):
+        """Test the schedule property."""
+        with self.subTest("Test TYPE_DAILY schedules"):
+            daily_utc_schedule = self.daily_utc_job.schedule
+            daily_est_schedule = self.daily_est_job.schedule
+            self.assertIsInstance(daily_utc_schedule, TzAwareCrontab)
+            self.assertIsInstance(daily_est_schedule, TzAwareCrontab)
+            self.assertNotEqual(daily_utc_schedule, daily_est_schedule)
+            # Crontabs are validated in test_to_cron()
+
+        with self.subTest("Test TYPE_CUSTOM schedules"):
+            crontab_utc_schedule = self.crontab_utc_job.schedule
+            crontab_est_schedule = self.crontab_est_job.schedule
+            self.assertIsInstance(crontab_utc_schedule, TzAwareCrontab)
+            self.assertIsInstance(crontab_est_schedule, TzAwareCrontab)
+            self.assertNotEqual(crontab_utc_schedule, crontab_est_schedule)
+            # Crontabs are validated in test_to_cron()
+
+        with self.subTest("Test TYPE_FUTURE schedules"):
+            # TYPE_FUTURE schedules are one off, not cron tabs:
+            self.assertEqual(self.one_off_utc_job.schedule.clocked_time, self.one_off_utc_job.start_time)
+            self.assertEqual(self.one_off_est_job.schedule.clocked_time, self.one_off_est_job.start_time)
+            self.assertEqual(
+                self.one_off_est_job.schedule.clocked_time - self.one_off_utc_job.schedule.clocked_time,
+                timedelta(hours=5),
+            )
+
+    def test_to_cron(self):
+        """Test the to_cron() method and its interaction with time zone variants."""
+
+        with self.subTest("Test TYPE_DAILY schedule with UTC time zone and UTC schedule time zone"):
+            self.daily_utc_job.refresh_from_db()
+            daily_utc_schedule = self.daily_utc_job.to_cron()
+            self.assertEqual(daily_utc_schedule.tz, ZoneInfo("UTC"))
+            self.assertEqual(daily_utc_schedule.hour, {17})
+            self.assertEqual(daily_utc_schedule.minute, {0})
+            last_run = datetime(2050, 1, 21, 17, 0, tzinfo=ZoneInfo("UTC"))
+            with time_machine.travel("2050-01-22 16:59 +0000"):
+                is_due, _ = daily_utc_schedule.is_due(last_run_at=last_run)
+                self.assertFalse(is_due)
+            with time_machine.travel("2050-01-22 17:00 +0000"):
+                is_due, _ = daily_utc_schedule.is_due(last_run_at=last_run)
+                self.assertTrue(is_due)
+
+        with self.subTest("Test TYPE_DAILY schedule with UTC time zone and EST schedule time zone"):
+            self.daily_est_job.refresh_from_db()
+            daily_est_schedule = self.daily_est_job.to_cron()
+            self.assertEqual(daily_est_schedule.tz, ZoneInfo("America/New_York"))
+            self.assertEqual(daily_est_schedule.hour, {17})
+            self.assertEqual(daily_est_schedule.minute, {0})
+            last_run = datetime(2050, 1, 21, 22, 0, tzinfo=ZoneInfo("UTC"))
+            with time_machine.travel("2050-01-22 21:59 +0000"):
+                is_due, _ = daily_est_schedule.is_due(last_run_at=last_run)
+                self.assertFalse(is_due)
+            with time_machine.travel("2050-01-22 22:00 +0000"):
+                is_due, _ = daily_est_schedule.is_due(last_run_at=last_run)
+                self.assertTrue(is_due)
+
+        with self.subTest("Test TYPE_CUSTOM schedule with UTC time zone and UTC schedule time zone"):
+            self.crontab_utc_job.refresh_from_db()
+            crontab_utc_schedule = self.crontab_utc_job.to_cron()
+            self.assertEqual(crontab_utc_schedule.tz, ZoneInfo("UTC"))
+            self.assertEqual(crontab_utc_schedule.hour, {17})
+            self.assertEqual(crontab_utc_schedule.minute, {0})
+
+        with self.subTest("Test TYPE_CUSTOM schedule with UTC time zone and EST schedule time zone"):
+            self.crontab_est_job.refresh_from_db()
+            crontab_est_schedule = self.crontab_est_job.to_cron()
+            self.assertEqual(crontab_est_schedule.tz, ZoneInfo("America/New_York"))
+            self.assertEqual(crontab_est_schedule.hour, {17})
+            self.assertEqual(crontab_est_schedule.minute, {0})
+
+        with self.subTest("Test TYPE_FUTURE schedules do not map to cron"):
+            with self.assertRaises(ValueError):
+                self.one_off_utc_job.to_cron()
+            with self.assertRaises(ValueError):
+                self.one_off_est_job.to_cron()
+
+        with override_settings(TIME_ZONE="America/New_York"):
+            with self.subTest("Test TYPE_DAILY schedule with EST time zone and UTC schedule time zone"):
+                self.daily_utc_job.refresh_from_db()
+                daily_utc_schedule = self.daily_utc_job.to_cron()
+                self.assertEqual(daily_utc_schedule.tz, ZoneInfo("UTC"))
+                self.assertEqual(daily_utc_schedule.hour, {17})
+                self.assertEqual(daily_utc_schedule.minute, {0})
+                last_run = datetime(2050, 1, 21, 12, 0, tzinfo=ZoneInfo("America/New_York"))
+                with time_machine.travel("2050-01-22 11:59 -0500"):
+                    is_due, _ = daily_utc_schedule.is_due(last_run_at=last_run)
+                    self.assertFalse(is_due)
+                with time_machine.travel("2050-01-22 12:00 -0500"):
+                    is_due, _ = daily_utc_schedule.is_due(last_run_at=last_run)
+                    self.assertTrue(is_due)
+
+            with self.subTest("Test TYPE_DAILY schedule with EST time zone and EST schedule time zone"):
+                self.daily_est_job.refresh_from_db()
+                daily_est_schedule = self.daily_est_job.to_cron()
+                self.assertEqual(daily_est_schedule.tz, ZoneInfo("America/New_York"))
+                self.assertEqual(daily_est_schedule.hour, {17})
+                self.assertEqual(daily_est_schedule.minute, {0})
+                last_run = datetime(2050, 1, 21, 22, 0, tzinfo=ZoneInfo("America/New_York"))
+                with time_machine.travel("2050-01-22 16:59 -0500"):
+                    is_due, _ = daily_est_schedule.is_due(last_run_at=last_run)
+                    self.assertFalse(is_due)
+                with time_machine.travel("2050-01-22 17:00 -0500"):
+                    is_due, _ = daily_est_schedule.is_due(last_run_at=last_run)
+                    self.assertTrue(is_due)
+
+            with self.subTest("Test TYPE_CUSTOM schedule with EST time zone and UTC schedule time zone"):
+                self.crontab_utc_job.refresh_from_db()
+                crontab_utc_schedule = self.crontab_utc_job.to_cron()
+                self.assertEqual(crontab_utc_schedule.tz, ZoneInfo("UTC"))
+                self.assertEqual(crontab_utc_schedule.hour, {17})
+                self.assertEqual(crontab_utc_schedule.minute, {0})
+
+            with self.subTest("Test TYPE_CUSTOM schedule with EST time zone and EST schedule time zone"):
+                self.crontab_est_job.refresh_from_db()
+                crontab_est_schedule = self.crontab_est_job.to_cron()
+                self.assertEqual(crontab_est_schedule.tz, ZoneInfo("America/New_York"))
+                self.assertEqual(crontab_est_schedule.hour, {17})
+                self.assertEqual(crontab_est_schedule.minute, {0})
+
+    def test_crontab_dst(self):
+        """Test that TYPE_CUSTOM behavior around DST is as expected."""
+        cronjob = ScheduledJob.objects.create(
+            name="DST Aware Cronjob",
+            task="pass.TestPass",
+            job_model=self.job_model,
+            enabled=False,
+            interval=JobExecutionType.TYPE_CUSTOM,
+            start_time=datetime(year=2024, month=1, day=1, hour=17, minute=0, tzinfo=ZoneInfo("America/New_York")),
+            crontab="0 17 * * *",  # 5 PM local time
+            time_zone=ZoneInfo("America/New_York"),
+        )
+
+        # Before DST takes effect
+        with self.subTest("Test UTC time zone with EST job"):
+            cronjob.refresh_from_db()
+            crontab = cronjob.to_cron()
+            with time_machine.travel("2024-03-09 21:59 +0000"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 8, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertFalse(is_due)
+            with time_machine.travel("2024-03-09 22:00 +0000"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 8, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertTrue(is_due)
+
+        with self.subTest("Test EST time zone with EST job"), override_settings(TIME_ZONE="America/New_York"):
+            cronjob.refresh_from_db()
+            crontab = cronjob.to_cron()
+            with time_machine.travel("2024-03-09 16:59 -0500"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 8, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertFalse(is_due)
+            with time_machine.travel("2024-03-09 17:00 -0500"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 8, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertTrue(is_due)
+
+        # Day that DST takes effect
+        with self.subTest("Test UTC time zone with EDT job"):
+            cronjob.refresh_from_db()
+            crontab = cronjob.to_cron()
+            with time_machine.travel("2024-03-10 20:59 +0000"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 9, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertFalse(is_due)
+            with time_machine.travel("2024-03-10 21:00 +0000"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 9, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertTrue(is_due)
+
+        with self.subTest("Test EDT time zone with EDT job"), override_settings(TIME_ZONE="America/New_York"):
+            cronjob.refresh_from_db()
+            crontab = cronjob.to_cron()
+            with time_machine.travel("2024-03-10 16:59 -0400"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 9, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertFalse(is_due)
+            with time_machine.travel("2024-03-10 17:00 -0400"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 9, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertTrue(is_due)
+
+    def test_daily_dst(self):
+        """Test the interaction of TYPE_DAILY around DST."""
+        daily = ScheduledJob.objects.create(
+            name="Daily Job",
+            task="pass.TestPass",
+            job_model=self.job_model,
+            enabled=False,
+            interval=JobExecutionType.TYPE_DAILY,
+            start_time=datetime(year=2024, month=1, day=1, hour=17, minute=0, tzinfo=ZoneInfo("America/New_York")),
+            time_zone=ZoneInfo("America/New_York"),
+        )
+
+        # Before DST takes effect
+        with self.subTest("Test UTC time zone with EST job"):
+            daily.refresh_from_db()
+            crontab = daily.to_cron()
+            with time_machine.travel("2024-03-09 21:59 +0000"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 8, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertFalse(is_due)
+            with time_machine.travel("2024-03-09 22:00 +0000"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 8, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertTrue(is_due)
+
+        with self.subTest("Test EST time zone with EST job"), override_settings(TIME_ZONE="America/New_York"):
+            daily.refresh_from_db()
+            crontab = daily.to_cron()
+            with time_machine.travel("2024-03-09 16:59 -0500"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 8, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertFalse(is_due)
+            with time_machine.travel("2024-03-09 17:00 -0500"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 8, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertTrue(is_due)
+
+        # Day that DST takes effect
+        with self.subTest("Test UTC time zone with EDT job"):
+            daily.refresh_from_db()
+            crontab = daily.to_cron()
+            with time_machine.travel("2024-03-10 20:59 +0000"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 9, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertFalse(is_due)
+            with time_machine.travel("2024-03-10 21:00 +0000"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 9, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertTrue(is_due)
+
+        with self.subTest("Test EDT time zone with EDT job"), override_settings(TIME_ZONE="America/New_York"):
+            daily.refresh_from_db()
+            crontab = daily.to_cron()
+            with time_machine.travel("2024-03-10 16:59 -0400"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 9, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertFalse(is_due)
+            with time_machine.travel("2024-03-10 17:00 -0400"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 9, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertTrue(is_due)
+
+
 class SecretTest(ModelTestCases.BaseModelTestCase):
     """
     Tests for the `Secret` model class.

nautobot/extras/tests/test_views.py

@@ -1744,16 +1744,17 @@ class ScheduledJobTestCase(
         ScheduledJob.objects.create(
             name="test2",
             task="pass.TestPass",
-            interval=JobExecutionType.TYPE_IMMEDIATELY,
+            interval=JobExecutionType.TYPE_DAILY,
             user=user,
             start_time=timezone.now(),
         )
         ScheduledJob.objects.create(
             name="test3",
             task="pass.TestPass",
-            interval=JobExecutionType.TYPE_IMMEDIATELY,
+            interval=JobExecutionType.TYPE_CUSTOM,
             user=user,
             start_time=timezone.now(),
+            crontab="15 10 * * *",
         )
 
     def test_only_enabled_is_listed(self):
@@ -2594,7 +2595,7 @@ class JobTestCase(
 
         self.assertInHTML('<option value="uniquequeue" selected>', content)
         self.assertInHTML(
-            '<input type="text" name="var" value="456" class="form-control form-control" required placeholder="None" id="id_var">',
+            '<input type="text" name="var" value="456" class="form-control" required placeholder="None" id="id_var">',
             content,
         )
         self.assertInHTML('<input type="hidden" name="_profile" value="True" id="id__profile">', content)
@@ -2994,6 +2995,27 @@ class JobButtonRenderingTestCase(TestCase):
             )
 
 
+class JobCustomTemplateTestCase(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        # Job model objects are automatically created during database migrations
+
+        # But we do need to make sure the ones we're testing are flagged appropriately
+        cls.example_job = Job.objects.get(job_class_name="ExampleCustomFormJob")
+        cls.example_job.enabled = True
+        cls.example_job.save()
+
+        cls.run_url = reverse("extras:job_run", kwargs={"pk": cls.example_job.pk})
+
+    def test_rendering_custom_template(self):
+        obj_perm = ObjectPermission(name="Test permission", actions=["view", "run"])
+        obj_perm.save()
+        obj_perm.users.add(self.user)
+        obj_perm.object_types.add(ContentType.objects.get_for_model(Job))
+        with self.assertTemplateUsed("example_app/custom_job_form.html"):
+            self.client.get(self.run_url)
+
+
 # TODO: Convert to StandardTestCases.Views
 class ObjectChangeTestCase(TestCase):
     user_permissions = ("extras.view_objectchange",)
@@ -3029,8 +3051,7 @@ class ObjectChangeTestCase(TestCase):
 
 
 class ObjectMetadataTestCase(
-    ViewTestCases.DeleteObjectViewTestCase,
-    ViewTestCases.BulkDeleteObjectsViewTestCase,
+    ViewTestCases.GetObjectViewTestCase,
     ViewTestCases.GetObjectChangelogViewTestCase,
     ViewTestCases.ListObjectsViewTestCase,
 ):

nautobot/extras/utils.py

@@ -1,4 +1,5 @@
 import collections
+import contextlib
 import hashlib
 import hmac
 import logging
@@ -14,6 +15,7 @@ from django.db import transaction
 from django.db.models import Q
 from django.template.loader import get_template, TemplateDoesNotExist
 from django.utils.deconstruct import deconstructible
+import redis.exceptions
 
 from nautobot.core.choices import ColorChoices
 from nautobot.core.constants import CHARFIELD_MAX_LENGTH
@@ -109,12 +111,17 @@ class ChangeLoggedModelsQuery(FeaturedQueryMixin):
 def change_logged_models_queryset():
     """
     Cacheable function for cases where we need this queryset many times, such as when saving multiple objects.
+
+    Cache is cleared by post_migrate signal (nautobot.extras.signals.post_migrate_clear_content_type_caches).
     """
+    queryset = None
     cache_key = "nautobot.extras.utils.change_logged_models_queryset"
-    queryset = cache.get(cache_key)
+    with contextlib.suppress(redis.exceptions.ConnectionError):
+        queryset = cache.get(cache_key)
     if queryset is None:
         queryset = ChangeLoggedModelsQuery().as_queryset()
-        cache.set(cache_key, queryset)
+        with contextlib.suppress(redis.exceptions.ConnectionError):
+            cache.set(cache_key, queryset)
     return queryset
 
 
@@ -160,7 +167,7 @@ class FeatureQuery:
         """
         Given an extras feature, return a iterable of app_label: [models] for content type lookup.
 
-        Mis-named, as it returns an iterable of (key, value) (i.e. dict.items()) rather than an actual dict.
+        Misnamed, as it returns an iterable of (key, value) (i.e. dict.items()) rather than an actual dict.
 
         Raises a KeyError if the given feature doesn't exist.
         """
@@ -173,12 +180,34 @@ class FeatureQuery:
 
             >>> FeatureQuery('statuses').get_choices()
             [('dcim.device', 13), ('dcim.rack', 34)]
+
+        Cache is cleared by post_migrate signal (nautobot.extras.signals.post_migrate_clear_content_type_caches).
         """
-        return [(f"{ct.app_label}.{ct.model}", ct.pk) for ct in ContentType.objects.filter(self.get_query())]
+        choices = None
+        cache_key = f"nautobot.extras.utils.FeatureQuery.choices.{self.feature}"
+        with contextlib.suppress(redis.exceptions.ConnectionError):
+            choices = cache.get(cache_key)
+        if choices is None:
+            choices = [(f"{ct.app_label}.{ct.model}", ct.pk) for ct in ContentType.objects.filter(self.get_query())]
+            with contextlib.suppress(redis.exceptions.ConnectionError):
+                cache.set(cache_key, choices)
+        return choices
 
     def list_subclasses(self):
-        """Return a list of model classes that declare this feature."""
-        return [ct.model_class() for ct in ContentType.objects.filter(self.get_query())]
+        """
+        Return a list of model classes that declare this feature.
+
+        Cache is cleared by post_migrate signal (nautobot.extras.signals.post_migrate_clear_content_type_caches).
+        """
+        subclasses = None
+        cache_key = f"nautobot.extras.utils.FeatureQuery.subclasses.{self.feature}"
+        with contextlib.suppress(redis.exceptions.ConnectionError):
+            subclasses = cache.get(cache_key)
+        if subclasses is None:
+            subclasses = [ct.model_class() for ct in ContentType.objects.filter(self.get_query())]
+            with contextlib.suppress(redis.exceptions.ConnectionError):
+                cache.set(cache_key, subclasses)
+        return subclasses
 
 
 @deconstructible