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

nautobot/extras/tests/test_forms.py

@@ -4,13 +4,12 @@ import warnings
 from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
 from django.db.models import Q
-from django.forms import ChoiceField, MultipleChoiceField
 from django.test import override_settings, TestCase
 
 from nautobot.dcim.forms import DeviceForm, LocationBulkEditForm, LocationForm
 import nautobot.dcim.models as dcim_models
 from nautobot.dcim.models import Device, Location, LocationType
-from nautobot.extras.choices import CustomFieldTypeChoices, RelationshipTypeChoices
+from nautobot.extras.choices import RelationshipTypeChoices
 from nautobot.extras.forms import (
     ConfigContextFilterForm,
     ConfigContextForm,
@@ -26,7 +25,6 @@ from nautobot.extras.forms import (
     WebhookForm,
 )
 from nautobot.extras.models import (
-    CustomField,
     Job,
     JobButton,
     JobHook,
@@ -1219,20 +1217,3 @@ class CustomFieldModelFormMixinTestCase(TestCase):
 
         custom_field_form = TestForm()
         self.assertIn("_custom_field_data", custom_field_form.fields)
-
-
-class CustomFieldTestCase(TestCase):
-    def test_to_form_field_type_select(self):
-        """Verify that `to_form_field` and `to_filter_form_field` return the correct field types for a select-type CustomField."""
-        custom_field = CustomField.objects.create(
-            type=CustomFieldTypeChoices.TYPE_SELECT,
-            label="Custom Field Select",
-        )
-        form = custom_field.to_filter_form_field()
-        self.assertIsInstance(form, MultipleChoiceField)
-
-        form = custom_field.to_form_field(for_filter_form=True)
-        self.assertIsInstance(form, MultipleChoiceField)
-
-        form = custom_field.to_form_field(for_filter_form=False)
-        self.assertIsInstance(form, ChoiceField)

nautobot/extras/tests/test_job_variables.py

@@ -1,6 +1,6 @@
+from django.core.exceptions import ValidationError
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.test import TestCase
-from netaddr import IPAddress, IPNetwork
 
 from nautobot.dcim.models import Device
 from nautobot.extras.jobs import (
@@ -11,7 +11,6 @@ from nautobot.extras.jobs import (
     IPAddressVar,
     IPAddressWithMaskVar,
     IPNetworkVar,
-    Job,
     JSONVar,
     MultiChoiceVar,
     MultiObjectVar,
@@ -26,238 +25,160 @@ 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]+")
+        field = StringVar(min_length=3, max_length=3, regex=r"[a-z]+").as_field()
 
         # Validate min_length enforcement
-        data = {"var1": "xx"}
-        form = StringVarJob().as_form(data)
-        self.assertFalse(form.is_valid())
-        self.assertIn("var1", form.errors)
+        with self.assertRaises(ValidationError) as cm:
+            field.clean("xx")
+        self.assertIn("Ensure this value has at least 3 characters (it has 2).", str(cm.exception))
 
         # Validate max_length enforcement
-        data = {"var1": "xxxx"}
-        form = StringVarJob().as_form(data)
-        self.assertFalse(form.is_valid())
-        self.assertIn("var1", form.errors)
+        with self.assertRaises(ValidationError) as cm:
+            field.clean("xxxx")
+        self.assertIn("Ensure this value has at most 3 characters (it has 4).", str(cm.exception))
 
         # Validate regex enforcement
-        data = {"var1": "ABC"}
-        form = StringVarJob().as_form(data)
-        self.assertFalse(form.is_valid())
-        self.assertIn("var1", form.errors)
+        with self.assertRaises(ValidationError) as cm:
+            field.clean("ABC")
+        self.assertIn("Invalid value. Must match regex: [a-z]+'", str(cm.exception))
 
         # Validate valid data
-        data = {"var1": "abc"}
-        form = StringVarJob().as_form(data)
-        self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data["var1"], data["var1"])
+        field.clean("abc")
 
     def test_textvar(self):
-        class TextVarJob(Job):
-            var1 = TextVar()
+        field = TextVar().as_field()
 
         # Validate valid data
-        data = {"var1": "This is a test string"}
-        form = TextVarJob().as_form(data)
-        self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data["var1"], data["var1"])
+        field.clean("This is a test string")
 
     def test_integervar(self):
-        class IntegerVarJob(Job):
-            var1 = IntegerVar(min_value=5, max_value=10)
+        field = IntegerVar(min_value=5, max_value=10).as_field()
 
         # Validate min_value enforcement
-        data = {"var1": 4}
-        form = IntegerVarJob().as_form(data)
-        self.assertFalse(form.is_valid())
-        self.assertIn("var1", form.errors)
+        with self.assertRaises(ValidationError) as cm:
+            field.clean(4)
+        self.assertIn("Ensure this value is greater than or equal to 5.", str(cm.exception))
 
         # Validate max_value enforcement
-        data = {"var1": 11}
-        form = IntegerVarJob().as_form(data)
-        self.assertFalse(form.is_valid())
-        self.assertIn("var1", form.errors)
+        with self.assertRaises(ValidationError) as cm:
+            field.clean(11)
+        self.assertIn("Ensure this value is less than or equal to 10.", str(cm.exception))
 
         # Validate valid data
-        data = {"var1": 7}
-        form = IntegerVarJob().as_form(data)
-        self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data["var1"], data["var1"])
+        field.clean(7)
 
     def test_booleanvar(self):
-        class BooleanVarJob(Job):
-            var1 = BooleanVar()
+        field = BooleanVar().as_field()
 
         # Validate True
-        data = {"var1": True}
-        form = BooleanVarJob().as_form(data)
-        self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data["var1"], True)
+        field.clean(True)
 
         # Validate False
-        data = {"var1": False}
-        form = BooleanVarJob().as_form(data)
-        self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data["var1"], False)
+        field.clean(False)
 
     def test_choicevar(self):
-        class ChoiceVarJob(Job):
-            var1 = ChoiceVar(choices=CHOICES)
+        field = ChoiceVar(choices=CHOICES).as_field()
 
         # Validate valid choice
-        data = {"var1": "ff0000"}
-        form = ChoiceVarJob().as_form(data)
-        self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data["var1"], "ff0000")
+        field.clean("ff0000")
 
         # Validate invalid choice
-        data = {"var1": "taupe"}
-        form = ChoiceVarJob().as_form(data)
-        self.assertFalse(form.is_valid())
-        self.assertIn("var1", form.errors)
+        with self.assertRaises(ValidationError) as cm:
+            field.clean("taupe")
+        self.assertIn("Select a valid choice. taupe is not one of the available choices.", str(cm.exception))
 
     def test_multichoicevar(self):
-        class MultiChoiceVarJob(Job):
-            var1 = MultiChoiceVar(choices=CHOICES)
+        field = MultiChoiceVar(choices=CHOICES).as_field()
 
-        # Validate single choice
-        data = {"var1": ["ff0000"]}
-        form = MultiChoiceVarJob().as_form(data)
-        self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data["var1"], ["ff0000"])
+        # Validate valid choice
+        field.clean(["ff0000"])
 
         # Validate multiple choices
-        data = {"var1": ("ff0000", "00ff00")}
-        form = MultiChoiceVarJob().as_form(data)
-        self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data["var1"], ["ff0000", "00ff00"])
+        field.clean(("ff0000", "00ff00"))
 
         # Validate invalid choice
-        data = {"var1": "taupe"}
-        form = MultiChoiceVarJob().as_form(data)
-        self.assertFalse(form.is_valid())
-        self.assertIn("var1", form.errors)
+        with self.assertRaises(ValidationError) as cm:
+            field.clean(["taupe"])
+        self.assertIn("Select a valid choice. taupe is not one of the available choices.", str(cm.exception))
 
     def test_objectvar(self):
-        class ObjectVarJob(Job):
-            var1 = ObjectVar(model=Role)
+        field = ObjectVar(model=Role).as_field()
 
         # Validate valid data
-        data = {"var1": Role.objects.get_for_model(Device).first().pk}
-        form = ObjectVarJob().as_form(data)
-        self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data["var1"].pk, data["var1"])
+        field.clean(Role.objects.get_for_model(Device).first().pk)
 
     def test_multiobjectvar(self):
-        class MultiObjectVarJob(Job):
-            var1 = MultiObjectVar(model=Role)
+        field = MultiObjectVar(model=Role).as_field()
 
         # Validate valid data
-        data = {"var1": [role.pk for role in Role.objects.all()[:3]]}
-        form = MultiObjectVarJob().as_form(data)
-        self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data["var1"][0].pk, data["var1"][0])
-        self.assertEqual(form.cleaned_data["var1"][1].pk, data["var1"][1])
-        self.assertEqual(form.cleaned_data["var1"][2].pk, data["var1"][2])
+        field.clean([role.pk for role in Role.objects.all()[:3]])
 
     def test_filevar(self):
-        class FileVarJob(Job):
-            var1 = FileVar()
+        field = FileVar().as_field()
 
         # Test file
         testfile = SimpleUploadedFile(name="test_file.txt", content=b"This is an test file for testing")
-
         # Validate valid data
-        file_data = {"var1": testfile}
-        form = FileVarJob().as_form(data=None, files=file_data)
-        self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data["var1"], testfile)
+        field.clean(testfile)
 
     def test_ipaddressvar(self):
-        class IPAddressVarJob(Job):
-            var1 = IPAddressVar()
+        field = IPAddressVar().as_field()
 
         # Validate IP network enforcement
-        data = {"var1": "1.2.3"}
-        form = IPAddressVarJob().as_form(data)
-        self.assertFalse(form.is_valid())
-        self.assertIn("var1", form.errors)
+        with self.assertRaises(ValidationError) as cm:
+            field.clean("1.2.3")
+        self.assertIn("Invalid IPv4/IPv6 address format: 1.2.3", str(cm.exception))
 
         # Validate IP mask exclusion
-        data = {"var1": "192.0.2.0/24"}
-        form = IPAddressVarJob().as_form(data)
-        self.assertFalse(form.is_valid())
-        self.assertIn("var1", form.errors)
+        with self.assertRaises(ValidationError) as cm:
+            field.clean("192.0.2.0/24")
+        self.assertIn("Invalid IPv4/IPv6 address format: 192.0.2.0/24", str(cm.exception))
 
         # Validate valid data
-        data = {"var1": "192.0.2.1"}
-        form = IPAddressVarJob().as_form(data)
-        self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data["var1"], IPAddress(data["var1"]))
+        field.clean("192.0.2.1")
 
     def test_ipaddresswithmaskvar(self):
-        class IPAddressWithMaskVarJob(Job):
-            var1 = IPAddressWithMaskVar()
+        field = IPAddressWithMaskVar().as_field()
 
         # Validate IP network enforcement
-        data = {"var1": "1.2.3"}
-        form = IPAddressWithMaskVarJob().as_form(data)
-        self.assertFalse(form.is_valid())
-        self.assertIn("var1", form.errors)
+        with self.assertRaises(ValidationError) as cm:
+            field.clean("1.2.3")
+        self.assertIn("CIDR mask (e.g. /24) is required.", str(cm.exception))
 
         # Validate IP mask requirement
-        data = {"var1": "192.0.2.0"}
-        form = IPAddressWithMaskVarJob().as_form(data)
-        self.assertFalse(form.is_valid())
-        self.assertIn("var1", form.errors)
+        with self.assertRaises(ValidationError) as cm:
+            field.clean("192.0.2.0")
+        self.assertIn("CIDR mask (e.g. /24) is required.", str(cm.exception))
 
         # Validate valid data
-        data = {"var1": "192.0.2.0/24"}
-        form = IPAddressWithMaskVarJob().as_form(data)
-        self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data["var1"], IPNetwork(data["var1"]))
+        field.clean("192.0.2.0/24")
 
     def test_ipnetworkvar(self):
-        class IPNetworkVarJob(Job):
-            var1 = IPNetworkVar()
+        field = IPNetworkVar().as_field()
 
         # Validate IP network enforcement
-        data = {"var1": "1.2.3"}
-        form = IPNetworkVarJob().as_form(data)
-        self.assertFalse(form.is_valid())
-        self.assertIn("var1", form.errors)
+        with self.assertRaises(ValidationError) as cm:
+            field.clean("1.2.3")
+        self.assertIn("CIDR mask (e.g. /24) is required.", str(cm.exception))
 
         # Validate host IP check
-        data = {"var1": "192.0.2.1/24"}
-        form = IPNetworkVarJob().as_form(data)
-        self.assertFalse(form.is_valid())
-        self.assertIn("var1", form.errors)
+        with self.assertRaises(ValidationError) as cm:
+            field.clean("192.0.2.1/24")
+        self.assertIn("192.0.2.1/24 is not a valid prefix. Did you mean 192.0.2.0/24?", str(cm.exception))
 
         # Validate valid data
-        data = {"var1": "192.0.2.0/24"}
-        form = IPNetworkVarJob().as_form(data)
-        self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data["var1"], IPNetwork(data["var1"]))
+        field.clean("192.0.2.0/24")
 
     def test_jsonvar(self):
-        class JSONVarJob(Job):
-            var1 = JSONVar()
+        field = JSONVar().as_field()
 
         # Valid JSON value as dictionary
-        data = {"var1": {"key1": "value1"}}
-        form = JSONVarJob().as_form(data)
-        self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data["var1"], {"key1": "value1"})
+        field.clean({"key1": "value1"})
 
         # Valid JSON value as jsonified dictionary
-        data = {"var1": '{"key1": "value1"}'}
-        form = JSONVarJob().as_form(data)
-        self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data["var1"], {"key1": "value1"})
+        field.clean('{"key1": "value1"}')
 
         # Invalid JSON value
-        data = {"var1": '{"key1": True}'}
-        form = JSONVarJob().as_form(data)
-        self.assertFalse(form.is_valid())
-        self.assertIn("var1", form.errors)
+        with self.assertRaises(ValidationError) as cm:
+            field.clean('{"key1": True}')
+        self.assertIn("Enter a valid JSON.", str(cm.exception))

nautobot/extras/tests/test_jobs.py

@@ -12,6 +12,7 @@ from constance.test import override_config
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.cache import cache
+from django.core.exceptions import ValidationError
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.core.management import call_command
 from django.core.management.base import CommandError
@@ -30,6 +31,7 @@ from nautobot.dcim.models import Device, Location, LocationType
 from nautobot.extras import models
 from nautobot.extras.choices import (
     JobExecutionType,
+    JobQueueTypeChoices,
     JobResultStatusChoices,
     LogLevelChoices,
     ObjectChangeEventContextChoices,
@@ -71,7 +73,7 @@ class JobTest(TestCase):
         name = "TestFieldOrder"
         job_class = get_job(f"{module}.{name}")
         form = job_class().as_form()
-        self.assertSequenceEqual(list(form.fields.keys()), ["var1", "var2", "var23", "_task_queue", "_profile"])
+        self.assertSequenceEqual(list(form.fields.keys()), ["var1", "var2", "var23", "_job_queue", "_profile"])
 
     def test_no_field_order(self):
         """
@@ -81,7 +83,7 @@ class JobTest(TestCase):
         name = "TestNoFieldOrder"
         job_class = get_job(f"{module}.{name}")
         form = job_class().as_form()
-        self.assertSequenceEqual(list(form.fields.keys()), ["var23", "var2", "_task_queue", "_profile"])
+        self.assertSequenceEqual(list(form.fields.keys()), ["var23", "var2", "_job_queue", "_profile"])
 
     def test_no_field_order_inherited_variable(self):
         """
@@ -93,7 +95,7 @@ class JobTest(TestCase):
         form = job_class().as_form()
         self.assertSequenceEqual(
             list(form.fields.keys()),
-            ["testvar1", "b_testvar2", "a_testvar3", "_task_queue", "_profile"],
+            ["testvar1", "b_testvar2", "a_testvar3", "_job_queue", "_profile"],
         )
 
     def test_dryrun_default(self):
@@ -115,47 +117,36 @@ class JobTest(TestCase):
         form = job_class().as_form()
         self.assertEqual(form.fields["dryrun"].initial, job_model.dryrun_default)
 
-    @mock.patch("nautobot.extras.utils.get_celery_queues")
-    def test_job_class_task_queues(self, mock_get_celery_queues):
-        """
-        Test job form with custom task queues defined on the job class
-        """
-        module = "task_queues"
-        name = "TestWorkerQueues"
-        mock_get_celery_queues.return_value = {"celery": 4, "irrelevant": 5}
-        job_class, _ = get_job_class_and_model(module, name)
-        form = job_class().as_form()
-        self.assertInHTML(
-            """<tr><th><label for="id__task_queue">Task queue:</label></th>
-            <td><select name="_task_queue" class="form-control" placeholder="Task queue" id="id__task_queue">
-            <option value="celery">celery (4 workers)</option>
-            <option value="nonexistent">nonexistent (0 workers)</option></select><br>
-            <span class="helptext">The task queue to route this job to</span>
-            <input type="hidden" name="_profile" value="False" id="id__profile"></td></tr>""",
-            form.as_table(),
-        )
+    def test_job_task_queues_setter(self):
+        """Test the task_queues property setter on Job."""
+        module = "dry_run"
+        name = "TestDryRun"
+        _, job_model = get_job_class_and_model(module, name)
+
+        invalid_queue = "Invalid job Queue"
+        with self.assertRaises(ValidationError) as cm:
+            job_model.task_queues = [invalid_queue]
+            job_model.validated_save()
+        self.assertIn(f"Job Queue {invalid_queue} does not exist in the database.", str(cm.exception))
 
-    @mock.patch("nautobot.extras.utils.get_celery_queues")
-    def test_job_class_task_queues_override(self, mock_get_celery_queues):
+    def test_job_class_job_queues(self):
         """
-        Test job form with custom task queues defined on the job class and overridden on the model
+        Test job form with custom task queues defined on the job class
         """
         module = "task_queues"
         name = "TestWorkerQueues"
-        mock_get_celery_queues.return_value = {"default": 1, "irrelevant": 5}
         job_class, job_model = get_job_class_and_model(module, name)
-        job_model.task_queues = ["default", "priority"]
-        job_model.task_queues_override = True
-        job_model.save()
+        jq_1, _ = models.JobQueue.objects.get_or_create(
+            name="celery", defaults={"queue_type": JobQueueTypeChoices.TYPE_CELERY}
+        )
+        jq_2, _ = models.JobQueue.objects.get_or_create(
+            name="irrelevant", defaults={"queue_type": JobQueueTypeChoices.TYPE_CELERY}
+        )
+        job_model.job_queues.set([jq_1, jq_2])
         form = job_class().as_form()
-        self.assertInHTML(
-            """<tr><th><label for="id__task_queue">Task queue:</label></th>
-            <td><select name="_task_queue" class="form-control" placeholder="Task queue" id="id__task_queue">
-            <option value="default">default (1 worker)</option>
-            <option value="priority">priority (0 workers)</option>
-            </select><br><span class="helptext">The task queue to route this job to</span>
-            <input type="hidden" name="_profile" value="False" id="id__profile"></td></tr>""",
-            form.as_table(),
+        self.assertQuerySetEqual(
+            form.fields["_job_queue"].queryset,
+            models.JobQueue.objects.filter(jobs=job_model),
         )
 
     def test_supports_dryrun(self):
@@ -170,7 +161,7 @@ class JobTest(TestCase):
         self.assertTrue(job_model.supports_dryrun)
 
         module = "pass"
-        name = "TestPassJob"
+        name = "TestPass"
         job_class, job_model = get_job_class_and_model(module, name)
         self.assertFalse(job_class.supports_dryrun)
         self.assertFalse(job_model.supports_dryrun)
@@ -212,7 +203,7 @@ register_jobs(MyJob)
                     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.TestPassJob", 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:
@@ -319,7 +310,7 @@ class JobTransactionTest(TransactionTestCase):
         Job test with pass result.
         """
         module = "pass"
-        name = "TestPassJob"
+        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)
@@ -353,7 +344,7 @@ class JobTransactionTest(TransactionTestCase):
         Job test with fail result.
         """
         module = "fail"
-        name = "TestFailJob"
+        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
@@ -588,7 +579,7 @@ class JobTransactionTest(TransactionTestCase):
         Job test to see if the latest_result property is indeed returning the most recent job result
         """
         module = "pass"
-        name = "TestPassJob"
+        name = "TestPass"
         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)
@@ -803,7 +794,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 = "TestPassJob"
+        name = "TestPass"
         _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)
@@ -890,9 +881,7 @@ class JobButtonReceiverTest(TestCase):
         name = "TestJobButtonReceiverSimple"
         job_class, _job_model = get_job_class_and_model(module, name)
         form = job_class().as_form()
-        self.assertSequenceEqual(
-            list(form.fields.keys()), ["object_pk", "object_model_name", "_task_queue", "_profile"]
-        )
+        self.assertSequenceEqual(list(form.fields.keys()), ["object_pk", "object_model_name", "_job_queue", "_profile"])
 
     def test_hidden(self):
         module = "job_button_receiver"
@@ -903,7 +892,7 @@ class JobButtonReceiverTest(TestCase):
     def test_is_job_button(self):
         with self.subTest(expected=False):
             module = "pass"
-            name = "TestPassJob"
+            name = "TestPass"
             _job_class, job_model = get_job_class_and_model(module, name)
             self.assertFalse(job_model.is_job_button_receiver)
 
@@ -955,7 +944,7 @@ class JobHookReceiverTest(TestCase):
         name = "TestJobHookReceiverLog"
         job_class, _job_model = get_job_class_and_model(module, name)
         form = job_class().as_form()
-        self.assertSequenceEqual(list(form.fields.keys()), ["object_change", "_task_queue", "_profile"])
+        self.assertSequenceEqual(list(form.fields.keys()), ["object_change", "_job_queue", "_profile"])
 
     def test_hidden(self):
         module = "job_hook_receiver"
@@ -966,7 +955,7 @@ class JobHookReceiverTest(TestCase):
     def test_is_job_hook(self):
         with self.subTest(expected=False):
             module = "pass"
-            name = "TestPassJob"
+            name = "TestPass"
             _job_class, job_model = get_job_class_and_model(module, name)
             self.assertFalse(job_model.is_job_hook_receiver)
 
@@ -1090,7 +1079,7 @@ class JobHookTransactionTest(TransactionTestCase):  # TODO: BaseModelTestCase mi
             ("info", "action: create"),
             ("info", f"jobresult.user: {self.user.username}"),
             ("info", "Test Job Hook Location 1"),
-            ("info", "Job completed"),
+            ("success", "Job completed"),
         ]
         log_messages = models.JobLogEntry.objects.filter(job_result=job_result).values_list("log_level", "message")
         self.assertSequenceEqual(log_messages, expected_log_messages)
@@ -1116,7 +1105,7 @@ class JobHookTransactionTest(TransactionTestCase):  # TODO: BaseModelTestCase mi
             ("info", "action: update"),
             ("info", f"jobresult.user: {self.user.username}"),
             ("info", "Test Job Hook Location 1"),
-            ("info", "Job completed"),
+            ("success", "Job completed"),
         ]
         log_messages = models.JobLogEntry.objects.filter(job_result=job_result).values_list("log_level", "message")
         self.assertSequenceEqual(log_messages, expected_log_messages)
@@ -1127,7 +1116,7 @@ class RemoveScheduledJobManagementCommandTestCase(TestCase):
         for i in range(1, 7):
             models.ScheduledJob.objects.create(
                 name=f"test{i}",
-                task="pass.TestPassJob",
+                task="pass.TestPass",
                 interval=JobExecutionType.TYPE_FUTURE,
                 user=self.user,
                 start_time=timezone.now() - datetime.timedelta(days=i * 30),
@@ -1136,7 +1125,7 @@ class RemoveScheduledJobManagementCommandTestCase(TestCase):
 
         models.ScheduledJob.objects.create(
             name="test7",
-            task="pass.TestPassJob",
+            task="pass.TestPass",
             interval=JobExecutionType.TYPE_DAILY,
             user=self.user,
             start_time=timezone.now() - datetime.timedelta(days=180),
@@ -1164,7 +1153,7 @@ class ScheduledJobIntervalTestCase(TestCase):
         start_time = timezone.now() + datetime.timedelta(days=6)
         scheduled_job = models.ScheduledJob.objects.create(
             name="weekly_interval",
-            task="pass.TestPassJob",
+            task="pass.TestPass",
             interval=JobExecutionType.TYPE_WEEKLY,
             user=self.user,
             start_time=start_time,