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

nautobot/extras/tests/test_models.py

@@ -4,6 +4,7 @@ import tempfile
 from unittest import expectedFailure, mock
 import uuid
 import warnings
+from zoneinfo import ZoneInfo
 
 from django.conf import settings
 from django.contrib.auth import get_user_model
@@ -19,11 +20,6 @@ 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
 from nautobot.core.testing import TestCase
@@ -66,6 +62,7 @@ from nautobot.extras.models import (
     GitRepository,
     Job as JobModel,
     JobLogEntry,
+    JobQueue,
     JobResult,
     MetadataChoice,
     MetadataType,
@@ -1086,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="TestPassJob")
+        cls.local_job = JobModel.objects.get(job_class_name="TestPass")
         cls.job_containing_sensitive_variables = JobModel.objects.get(job_class_name="ExampleLoggingJob")
         cls.app_job = JobModel.objects.get(job_class_name="ExampleJob")
 
@@ -1098,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.TestPassJob")
+        self.assertEqual(self.local_job.class_path, "pass.TestPass")
         self.assertIsNotNone(self.local_job.job_class)
         self.assertEqual(self.local_job.class_path, self.local_job.job_class.class_path)
 
@@ -1135,6 +1132,11 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
                                 getattr(job_model.job_class, field_name),
                                 field_name,
                             )
+                    if not job_model.job_queues_override:
+                        self.assertEqual(
+                            sorted(job_model.task_queues),
+                            sorted(job_model.job_class.task_queues) or [settings.CELERY_TASK_DEFAULT_QUEUE],
+                        )
                 except AssertionError:
                     print(list(JobModel.objects.all()))
                     print(registry["jobs"])
@@ -1159,7 +1161,6 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
             "has_sensitive_variables": not self.job_containing_sensitive_variables.has_sensitive_variables,
             "soft_time_limit": 350,
             "time_limit": 650,
-            "task_queues": ["overridden", "worker", "queues"],
         }
 
         # Override values to non-defaults and ensure they are preserved
@@ -1237,6 +1238,25 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
             "A job that may have sensitive variables cannot be marked as requiring approval",
         )
 
+    def test_default_job_queue_always_included_in_job_queues(self):
+        default_job_queue = JobQueue.objects.first()
+        job_queues = list(JobQueue.objects.exclude(pk=default_job_queue.pk))[:3]
+
+        job = JobModel.objects.first()
+        job.default_job_queue = default_job_queue
+        job.save()
+        job.job_queues.set(job_queues)
+
+        self.assertTrue(job.job_queues.filter(pk=default_job_queue.pk).exists())
+
+
+class JobQueueTest(ModelTestCases.BaseModelTestCase):
+    """
+    Tests for the `JobQueue` model class.
+    """
+
+    model = JobQueue
+
 
 class MetadataChoiceTest(ModelTestCases.BaseModelTestCase):
     model = MetadataChoice
@@ -1812,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="TestPassJob")
+        self.job_model = JobModel.objects.get(name="TestPass")
 
         self.daily_utc_job = ScheduledJob.objects.create(
             name="Daily UTC Job",
-            task="pass.TestPassJob",
+            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()),
@@ -1824,7 +1844,7 @@ class ScheduledJobTest(ModelTestCases.BaseModelTestCase):
         )
         self.daily_est_job = ScheduledJob.objects.create(
             name="Daily EST Job",
-            task="pass.TestPassJob",
+            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")),
@@ -1839,7 +1859,7 @@ class ScheduledJobTest(ModelTestCases.BaseModelTestCase):
         )
         self.crontab_est_job = ScheduledJob.objects.create(
             name="Crontab EST Job",
-            task="pass.TestPassJob",
+            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")),
@@ -1848,7 +1868,7 @@ class ScheduledJobTest(ModelTestCases.BaseModelTestCase):
         )
         self.one_off_utc_job = ScheduledJob.objects.create(
             name="One-off UTC Job",
-            task="pass.TestPassJob",
+            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")),
@@ -1862,6 +1882,14 @@ class ScheduledJobTest(ModelTestCases.BaseModelTestCase):
             start_time=datetime(year=2050, month=1, day=22, hour=0, minute=0, tzinfo=ZoneInfo("America/New_York")),
         )
 
+    def test_scheduled_job_queue_setter(self):
+        """Test the queue property setter on ScheduledJob."""
+        invalid_queue = "Invalid job Queue"
+        with self.assertRaises(ValidationError) as cm:
+            self.daily_utc_job.queue = invalid_queue
+            self.daily_utc_job.validated_save()
+        self.assertIn(f"Job Queue {invalid_queue} does not exist in the database.", str(cm.exception))
+
     def test_schedule(self):
         """Test the schedule property."""
         with self.subTest("Test TYPE_DAILY schedules"):
@@ -1987,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.TestPassJob",
+            task="pass.TestPass",
             job_model=self.job_model,
             enabled=False,
             interval=JobExecutionType.TYPE_CUSTOM,
@@ -2042,7 +2070,7 @@ class ScheduledJobTest(ModelTestCases.BaseModelTestCase):
         """Test the interaction of TYPE_DAILY around DST."""
         daily = ScheduledJob.objects.create(
             name="Daily Job",
-            task="pass.TestPassJob",
+            task="pass.TestPass",
             job_model=self.job_model,
             enabled=False,
             interval=JobExecutionType.TYPE_DAILY,
@@ -2092,6 +2120,33 @@ class ScheduledJobTest(ModelTestCases.BaseModelTestCase):
                 is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 9, 17, 0, tzinfo=ZoneInfo("America/New_York")))
                 self.assertTrue(is_due)
 
+    # TODO uncomment when we have a way to setup the NautobotDatabaseScheduler correctly
+    # @mock.patch("nautobot.extras.utils.run_kubernetes_job_and_return_job_result")
+    # def test_nautobot_database_scheduler_apply_async_method(self, mock_run_kubernetes_job_and_return_job_result):
+    #     jq = JobQueue.objects.create(name="kubernetes", queue_type=JobQueueTypeChoices.TYPE_KUBERNETES)
+    #     sj = ScheduledJob.objects.create(
+    #         name="Export Object List Hourly",
+    #         task="nautobot.core.jobs.ExportObjectList",
+    #         job_model=JobModel.objects.get(name="Export Object List"),
+    #         interval=JobExecutionType.TYPE_HOURLY,
+    #         user=User.objects.first(),
+    #         approval_required=False,
+    #         start_time=datetime.now(ZoneInfo("America/New_York")),
+    #         time_zone=ZoneInfo("America/New_York"),
+    #         job_queue=jq,
+    #         kwargs='{"content_type": 1}',
+    #     )
+    #     jr = JobResult.objects.create(
+    #         name=sj.job_model.name,
+    #         job_model=sj.job_model,
+    #         scheduled_job=sj,
+    #         user=sj.user,
+    #     )
+    #     mock_run_kubernetes_job_and_return_job_result.return_value = jr
+    #     entry = NautobotScheduleEntry(model=sj)
+    #     scheduler = NautobotDatabaseScheduler(app=entry.app)
+    #     scheduler.apply_async(entry=entry, producer=None, advance=False)
+
 
 class SecretTest(ModelTestCases.BaseModelTestCase):
     """
@@ -2583,7 +2638,7 @@ class JobLogEntryTest(TestCase):  # TODO: change to BaseModelTestCase
 
     def setUp(self):
         module = "pass"
-        name = "TestPassJob"
+        name = "TestPass"
         job_class = get_job(f"{module}.{name}")
 
         self.job_result = JobResult.objects.create(name=job_class.class_path, user=None)

nautobot/extras/tests/test_relationships.py

@@ -18,6 +18,7 @@ from nautobot.core.utils.lookup import get_route_for_model
 from nautobot.dcim.forms import DeviceForm
 from nautobot.dcim.models import (
     Controller,
+    ControllerManagedDeviceGroup,
     Device,
     DeviceType,
     DeviceTypeToSoftwareImageFile,
@@ -1325,7 +1326,7 @@ class RelationshipTableTest(RelationshipBaseTest, TestCase):
             self.assertIsNotNone(relationship_column)
             self.assertIsInstance(relationship_column, RelationshipColumn)
 
-            rendered_value = bound_row.get_cell(internal_col_name)  # pylint: disable=no-member
+            rendered_value = bound_row.get_cell(internal_col_name)
             # Test if the expected value is in the rendered value.
             # Exact match is difficult because the order of rendering is unpredictable.
             for value in col_expected_value:
@@ -1393,8 +1394,10 @@ class RequiredRelationshipTestMixin:
         # Protected FK to SoftwareImageFile prevents deletion
         DeviceTypeToSoftwareImageFile.objects.all().delete()
         # Protected FK to SoftwareVersion prevents deletion
-        Controller.objects.all().delete()
         Device.objects.all().update(software_version=None)
+
+        ControllerManagedDeviceGroup.objects.all().delete()
+        Controller.objects.all().delete()
         Device.objects.all().delete()
 
         # Create required relationships:

nautobot/extras/tests/test_utils.py

@@ -1,8 +1,11 @@
 from unittest import mock
+import uuid
 
 from django.core.cache import cache
 
 from nautobot.core.testing import TestCase
+from nautobot.extras.choices import JobQueueTypeChoices
+from nautobot.extras.models import JobQueue
 from nautobot.extras.registry import registry
 from nautobot.extras.utils import get_celery_queues, get_worker_count, populate_model_features_registry
 
@@ -45,14 +48,32 @@ class UtilsTestCase(TestCase):
     @mock.patch("nautobot.extras.utils.get_celery_queues")
     def test_get_worker_count(self, mock_get_celery_queues):
         mock_get_celery_queues.return_value = {"default": 12, "priority": 2, "bulk": 4, "nobody": 0}
+        JobQueue.objects.get_or_create(name="default", defaults={"queue_type": JobQueueTypeChoices.TYPE_CELERY})
+        priority_job_queue, _ = JobQueue.objects.get_or_create(
+            name="priority", defaults={"queue_type": JobQueueTypeChoices.TYPE_CELERY}
+        )
+        bulk_job_queue, _ = JobQueue.objects.get_or_create(
+            name="bulk", defaults={"queue_type": JobQueueTypeChoices.TYPE_CELERY}
+        )
+        empty_job_queue, _ = JobQueue.objects.get_or_create(
+            name="nobody", defaults={"queue_type": JobQueueTypeChoices.TYPE_CELERY}
+        )
         with self.subTest("Nonexistent queue"):
             self.assertEqual(get_worker_count(queue="invalid"), 0)
         with self.subTest("Default queue"):
             self.assertEqual(get_worker_count(), 12)
+        with self.subTest("Priority queue"):
+            self.assertEqual(get_worker_count(queue=priority_job_queue.name), 2)
         with self.subTest("Bulk queue"):
-            self.assertEqual(get_worker_count(queue="bulk"), 4)
+            self.assertEqual(get_worker_count(queue=bulk_job_queue.name), 4)
         with self.subTest("Empty queue"):
-            self.assertEqual(get_worker_count(queue="nobody"), 0)
+            self.assertEqual(get_worker_count(queue=empty_job_queue.name), 0)
+        with self.subTest("Passing a job queue instance"):
+            self.assertEqual(get_worker_count(queue=bulk_job_queue), 4)
+        with self.subTest("Passing a job queue pk"):
+            self.assertEqual(get_worker_count(queue=str(bulk_job_queue.pk)), 4)
+        with self.subTest("Passing a random uuid"):
+            self.assertEqual(get_worker_count(queue=str(uuid.uuid4())), 0)
 
     def test_populate_model_features_registry(self):
         original_custom_fields_registry = registry["model_features"]["custom_fields"].copy()