nautobot 2.2.2__py3-none-any.whl → 2.2.3__py3-none-any.whl

nautobot/extras/tests/test_job_variables.py

@@ -3,26 +3,32 @@ from django.test import TestCase
 from netaddr import IPAddress, IPNetwork
 
 from nautobot.dcim.models import Device
-from nautobot.extras.models import Role
-from nautobot.extras.test_jobs.job_variables import (
-    BooleanVarJob,
-    ChoiceVarJob,
-    FileVarJob,
-    IntegerVarJob,
-    IPAddressVarJob,
-    IPAddressWithMaskVarJob,
-    IPNetworkVarJob,
-    JSONVarJob,
-    MultiChoiceVarJob,
-    MultiObjectVarJob,
-    ObjectVarJob,
-    StringVarJob,
-    TextVarJob,
+from nautobot.extras.jobs import (
+    BooleanVar,
+    ChoiceVar,
+    FileVar,
+    IntegerVar,
+    IPAddressVar,
+    IPAddressWithMaskVar,
+    IPNetworkVar,
+    Job,
+    JSONVar,
+    MultiChoiceVar,
+    MultiObjectVar,
+    ObjectVar,
+    StringVar,
+    TextVar,
 )
+from nautobot.extras.models import Role
+
+CHOICES = (("ff0000", "Red"), ("00ff00", "Green"), ("0000ff", "Blue"))
 
 
 class JobVariablesTest(TestCase):
     def test_stringvar(self):
+        class StringVarJob(Job):
+            var1 = StringVar(min_length=3, max_length=3, regex=r"[a-z]+")
+
         # Validate min_length enforcement
         data = {"var1": "xx"}
         form = StringVarJob().as_form(data)
@@ -48,6 +54,9 @@ class JobVariablesTest(TestCase):
         self.assertEqual(form.cleaned_data["var1"], data["var1"])
 
     def test_textvar(self):
+        class TextVarJob(Job):
+            var1 = TextVar()
+
         # Validate valid data
         data = {"var1": "This is a test string"}
         form = TextVarJob().as_form(data)
@@ -55,6 +64,9 @@ class JobVariablesTest(TestCase):
         self.assertEqual(form.cleaned_data["var1"], data["var1"])
 
     def test_integervar(self):
+        class IntegerVarJob(Job):
+            var1 = IntegerVar(min_value=5, max_value=10)
+
         # Validate min_value enforcement
         data = {"var1": 4}
         form = IntegerVarJob().as_form(data)
@@ -74,6 +86,9 @@ class JobVariablesTest(TestCase):
         self.assertEqual(form.cleaned_data["var1"], data["var1"])
 
     def test_booleanvar(self):
+        class BooleanVarJob(Job):
+            var1 = BooleanVar()
+
         # Validate True
         data = {"var1": True}
         form = BooleanVarJob().as_form(data)
@@ -87,6 +102,9 @@ class JobVariablesTest(TestCase):
         self.assertEqual(form.cleaned_data["var1"], False)
 
     def test_choicevar(self):
+        class ChoiceVarJob(Job):
+            var1 = ChoiceVar(choices=CHOICES)
+
         # Validate valid choice
         data = {"var1": "ff0000"}
         form = ChoiceVarJob().as_form(data)
@@ -100,6 +118,9 @@ class JobVariablesTest(TestCase):
         self.assertIn("var1", form.errors)
 
     def test_multichoicevar(self):
+        class MultiChoiceVarJob(Job):
+            var1 = MultiChoiceVar(choices=CHOICES)
+
         # Validate single choice
         data = {"var1": ["ff0000"]}
         form = MultiChoiceVarJob().as_form(data)
@@ -119,6 +140,9 @@ class JobVariablesTest(TestCase):
         self.assertIn("var1", form.errors)
 
     def test_objectvar(self):
+        class ObjectVarJob(Job):
+            var1 = ObjectVar(model=Role)
+
         # Validate valid data
         data = {"var1": Role.objects.get_for_model(Device).first().pk}
         form = ObjectVarJob().as_form(data)
@@ -126,6 +150,9 @@ class JobVariablesTest(TestCase):
         self.assertEqual(form.cleaned_data["var1"].pk, data["var1"])
 
     def test_multiobjectvar(self):
+        class MultiObjectVarJob(Job):
+            var1 = MultiObjectVar(model=Role)
+
         # Validate valid data
         data = {"var1": [role.pk for role in Role.objects.all()[:3]]}
         form = MultiObjectVarJob().as_form(data)
@@ -135,6 +162,9 @@ class JobVariablesTest(TestCase):
         self.assertEqual(form.cleaned_data["var1"][2].pk, data["var1"][2])
 
     def test_filevar(self):
+        class FileVarJob(Job):
+            var1 = FileVar()
+
         # Test file
         testfile = SimpleUploadedFile(name="test_file.txt", content=b"This is an test file for testing")
 
@@ -145,6 +175,9 @@ class JobVariablesTest(TestCase):
         self.assertEqual(form.cleaned_data["var1"], testfile)
 
     def test_ipaddressvar(self):
+        class IPAddressVarJob(Job):
+            var1 = IPAddressVar()
+
         # Validate IP network enforcement
         data = {"var1": "1.2.3"}
         form = IPAddressVarJob().as_form(data)
@@ -164,6 +197,9 @@ class JobVariablesTest(TestCase):
         self.assertEqual(form.cleaned_data["var1"], IPAddress(data["var1"]))
 
     def test_ipaddresswithmaskvar(self):
+        class IPAddressWithMaskVarJob(Job):
+            var1 = IPAddressWithMaskVar()
+
         # Validate IP network enforcement
         data = {"var1": "1.2.3"}
         form = IPAddressWithMaskVarJob().as_form(data)
@@ -183,6 +219,9 @@ class JobVariablesTest(TestCase):
         self.assertEqual(form.cleaned_data["var1"], IPNetwork(data["var1"]))
 
     def test_ipnetworkvar(self):
+        class IPNetworkVarJob(Job):
+            var1 = IPNetworkVar()
+
         # Validate IP network enforcement
         data = {"var1": "1.2.3"}
         form = IPNetworkVarJob().as_form(data)
@@ -202,6 +241,9 @@ class JobVariablesTest(TestCase):
         self.assertEqual(form.cleaned_data["var1"], IPNetwork(data["var1"]))
 
     def test_jsonvar(self):
+        class JSONVarJob(Job):
+            var1 = JSONVar()
+
         # Valid JSON value as dictionary
         data = {"var1": {"key1": "value1"}}
         form = JSONVarJob().as_form(data)

nautobot/extras/tests/test_jobs.py

@@ -1,6 +1,7 @@
 import datetime
 from io import StringIO
 import json
+import os
 from pathlib import Path
 import re
 import tempfile
@@ -34,7 +35,7 @@ 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
+from nautobot.extras.jobs import get_job, get_jobs
 
 
 class JobTest(TestCase):
@@ -174,6 +175,111 @@ class JobTest(TestCase):
         self.assertFalse(job_class.supports_dryrun)
         self.assertFalse(job_model.supports_dryrun)
 
+    def test_submodule_in_jobs_root(self):
+        """
+        Test that a subdirectory/submodule in JOBS_ROOT can contain Jobs.
+        """
+        job_class, job_model = get_job_class_and_model("jobs_module.jobs_submodule.jobs", "ChildJob")
+        self.assertIsNotNone(job_class)
+        self.assertIsNotNone(job_model)
+
+    def test_relative_import_among_files_in_jobs_root(self):
+        """
+        Test that a module in JOBS_ROOT can import from other modules in JOBS_ROOT.
+        """
+        job_class, job_model = get_job_class_and_model("relative_import", "TestReallyPass")
+        self.assertIsNotNone(job_class)
+        self.assertIsNotNone(job_model)
+
+    def test_get_jobs_from_jobs_root(self):
+        """
+        Test that get_jobs() correctly loads jobs from JOBS_ROOT as its contents change.
+        """
+        try:
+            with tempfile.TemporaryDirectory() as temp_dir:
+                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("""\
+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())
+
+                    # Create a second Job in the same module
+                    with open(os.path.join(temp_dir, "my_jobs.py"), "a") as fd:
+                        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"))
+                    self.assertIn("my_jobs.MyOtherJob", jobs_data.keys())
+                    self.assertIsNotNone(get_job("my_jobs.MyOtherJob"))
+
+                    # Create a third Job in another module
+                    with open(os.path.join(temp_dir, "their_jobs.py"), "w") as fd:
+                        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"))
+                    self.assertIn("my_jobs.MyOtherJob", jobs_data.keys())
+                    self.assertIsNotNone(get_job("my_jobs.MyOtherJob"))
+                    self.assertIn("their_jobs.MyJob", jobs_data.keys())
+                    self.assertIsNotNone(get_job("their_jobs.MyJob"))
+                    self.assertNotEqual(get_job("my_jobs.MyJob"), get_job("their_jobs.MyJob"))
+
+                    # Delete a module
+                    os.remove(os.path.join(temp_dir, "their_jobs.py"))
+                    jobs_data = get_jobs(reload=True)
+                    self.assertIn("my_jobs.MyJob", jobs_data.keys())
+                    self.assertIsNotNone(get_job("my_jobs.MyJob"))
+                    self.assertIn("my_jobs.MyOtherJob", jobs_data.keys())
+                    self.assertIsNotNone(get_job("my_jobs.MyOtherJob"))
+                    self.assertNotIn("their_jobs", jobs_data.keys())
+                    self.assertIsNone(get_job("their_jobs.MyJob"))
+
+                    # Create a module with an inauspicious name
+                    with open(os.path.join(temp_dir, "traceback.py"), "w") as fd:
+                        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"))
+                    self.assertIn("my_jobs.MyOtherJob", jobs_data.keys())
+                    self.assertIsNotNone(get_job("my_jobs.MyOtherJob"))
+                    # Since `traceback` conflicts with a system module, it should not get loaded
+                    self.assertNotIn("traceback.BadJob", jobs_data.keys())
+                    self.assertIsNone(get_job("traceback.BadJob"))
+
+                    # TODO: testing with subdirectories/submodules under JOBS_ROOT...
+        finally:
+            # Clean up back to normal behavior
+            get_jobs(reload=True)
+
 
 class JobTransactionTest(TransactionTestCase):
     """
@@ -216,6 +322,19 @@ class JobTransactionTest(TransactionTestCase):
         name = "TestPass"
         job_result = create_job_result_and_run_job(module, name)
         self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertEqual(job_result.result, True)
+        logs = job_result.job_log_entries
+        self.assertGreater(logs.count(), 0)
+        try:
+            logs.get(message="before_start() was called as expected")
+            logs.get(message="Success")
+            logs.get(message="on_success() 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_result_manager_censor_sensitive_variables(self):
         """
@@ -237,6 +356,18 @@ class JobTransactionTest(TransactionTestCase):
         name = "TestFail"
         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
 
     def test_job_fail_with_sanitization(self):
         """
@@ -876,6 +1007,7 @@ class JobHookReceiverTransactionTest(TransactionTestCase):
         test_location = Location.objects.get(name="test_jhr")
         oc = get_changes_for_model(test_location).first()
         self.assertEqual(oc.change_context, ObjectChangeEventContextChoices.CONTEXT_JOB_HOOK)
+        self.assertIsNotNone(job_result.user)
         self.assertEqual(oc.user_id, job_result.user.pk)
 
     def test_missing_receive_job_hook_method(self):
@@ -933,6 +1065,8 @@ class JobHookTransactionTest(TransactionTestCase):  # TODO: BaseModelTestCase mi
         module = "job_hook_receiver"
         name = "TestJobHookReceiverLog"
         self.job_class, self.job_model = get_job_class_and_model(module, name)
+        self.assertIsNotNone(self.job_class)
+        self.assertIsNotNone(self.job_model)
         job_hook = models.JobHook(
             name="JobHookTest",
             type_create=True,

nautobot/extras/tests/test_models.py

@@ -65,6 +65,7 @@ from nautobot.extras.models import (
     Webhook,
 )
 from nautobot.extras.models.statuses import StatusModel
+from nautobot.extras.registry import registry
 from nautobot.extras.secrets.exceptions import SecretParametersError, SecretProviderError, SecretValueNotFoundError
 from nautobot.ipam.models import IPAddress
 from nautobot.tenancy.models import Tenant
@@ -1079,25 +1080,31 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
     def test_defaults(self):
         """Verify that defaults for discovered JobModel instances are as expected."""
         for job_model in JobModel.objects.all():
-            self.assertTrue(job_model.installed)
-            # System jobs should be enabled by default, all others are disabled by default
-            if job_model.module_name.startswith("nautobot."):
-                self.assertTrue(job_model.enabled)
-            else:
-                self.assertFalse(job_model.enabled)
-            for field_name in JOB_OVERRIDABLE_FIELDS:
-                if field_name == "name" and "duplicate_name" in job_model.job_class.__module__:
-                    pass  # name field for test_duplicate_name jobs tested in test_duplicate_job_name below
-                else:
-                    self.assertFalse(
-                        getattr(job_model, f"{field_name}_override"),
-                        (field_name, getattr(job_model, field_name), getattr(job_model.job_class, field_name)),
-                    )
-                    self.assertEqual(
-                        getattr(job_model, field_name),
-                        getattr(job_model.job_class, field_name),
-                        field_name,
-                    )
+            with self.subTest(class_path=job_model.class_path):
+                try:
+                    self.assertTrue(job_model.installed)
+                    # System jobs should be enabled by default, all others are disabled by default
+                    if job_model.module_name.startswith("nautobot."):
+                        self.assertTrue(job_model.enabled)
+                    else:
+                        self.assertFalse(job_model.enabled)
+                    for field_name in JOB_OVERRIDABLE_FIELDS:
+                        if field_name == "name" and "duplicate_name" in job_model.job_class.__module__:
+                            pass  # name field for test_duplicate_name jobs tested in test_duplicate_job_name below
+                        else:
+                            self.assertFalse(
+                                getattr(job_model, f"{field_name}_override"),
+                                (field_name, getattr(job_model, field_name), getattr(job_model.job_class, field_name)),
+                            )
+                            self.assertEqual(
+                                getattr(job_model, field_name),
+                                getattr(job_model.job_class, field_name),
+                                field_name,
+                            )
+                except AssertionError:
+                    print(list(JobModel.objects.all()))
+                    print(registry["jobs"])
+                    raise
 
     def test_duplicate_job_name(self):
         self.assertTrue(JobModel.objects.filter(name="TestDuplicateNameNoMeta").exists())

nautobot/extras/tests/test_plugins.py

@@ -9,7 +9,6 @@ from django.urls import NoReverseMatch, reverse
 import netaddr
 
 from nautobot.circuits.models import Circuit, CircuitType, Provider
-from nautobot.core.celery import app
 from nautobot.core.testing import APIViewTestCases, disable_warnings, extract_page_body, TestCase, ViewTestCases
 from nautobot.dcim.models import Device, DeviceType, Location, LocationType, Manufacturer
 from nautobot.dcim.tests.test_views import create_test_device
@@ -114,9 +113,8 @@ class AppTest(TestCase):
         """
         from example_app.jobs import ExampleJob
 
-        self.assertIn(ExampleJob, registry.get("plugin_jobs", []))
+        self.assertIn(ExampleJob.class_path, registry.get("jobs", {}))
         self.assertEqual(ExampleJob, get_job("example_app.jobs.ExampleJob"))
-        self.assertIn("example_app.jobs.ExampleJob", app.tasks)
 
     def test_git_datasource_contents_registration(self):
         """

nautobot/extras/tests/test_views.py

@@ -1765,10 +1765,8 @@ class JobTestCase(
     model = Job
 
     def _get_queryset(self):
-        """Don't include hidden Jobs, non-installed Jobs, JobHookReceivers or JobButtonReceivers as they won't appear in the UI by default."""
-        return self.model.objects.filter(
-            installed=True, hidden=False, is_job_hook_receiver=False, is_job_button_receiver=False
-        )
+        """Don't include hidden Jobs or non-installed Jobs, as they won't appear in the UI by default."""
+        return self.model.objects.filter(installed=True, hidden=False)
 
     @classmethod
     def setUpTestData(cls):