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

nautobot/extras/tests/test_relationships.py

@@ -12,7 +12,7 @@ from nautobot.core.forms import (
     DynamicModelMultipleChoiceField,
 )
 from nautobot.core.tables import RelationshipColumn
-from nautobot.core.testing import TestCase
+from nautobot.core.testing import create_job_result_and_run_job, TestCase, TransactionTestCase
 from nautobot.core.testing.models import ModelTestCases
 from nautobot.core.utils.lookup import get_route_for_model
 from nautobot.dcim.forms import DeviceForm
@@ -29,9 +29,22 @@ from nautobot.dcim.models import (
 )
 from nautobot.dcim.tables import LocationTable
 from nautobot.dcim.tests.test_views import create_test_device
-from nautobot.extras.choices import RelationshipRequiredSideChoices, RelationshipSideChoices, RelationshipTypeChoices
-from nautobot.extras.models import Relationship, RelationshipAssociation, Role, Status
-from nautobot.ipam.models import VLAN, VLANGroup
+from nautobot.extras.choices import (
+    JobResultStatusChoices,
+    LogLevelChoices,
+    RelationshipRequiredSideChoices,
+    RelationshipSideChoices,
+    RelationshipTypeChoices,
+)
+from nautobot.extras.models import (
+    Relationship,
+    RelationshipAssociation,
+    Role,
+    Status,
+)
+from nautobot.extras.models.jobs import JobLogEntry
+from nautobot.ipam.models import IPAddress, Prefix, VLAN, VLANGroup
+from nautobot.wireless.models import ControllerManagedDeviceGroupWirelessNetworkAssignment
 
 
 class RelationshipBaseTest:
@@ -354,20 +367,24 @@ class RelationshipTest(RelationshipBaseTest, ModelTestCases.BaseModelTestCase):
         self.assertFalse(field.required)
         self.assertIsInstance(field, DynamicModelMultipleChoiceField)
         self.assertEqual(field.label, "My VLANs")
-        self.assertEqual(field.query_params, {})
+        self.assertEqual(field.query_params, {"exclude_m2m": "true"})
 
         field = self.m2m_1.to_form_field("destination")
         self.assertFalse(field.required)
         self.assertIsInstance(field, DynamicModelMultipleChoiceField)
         self.assertEqual(field.label, "My Racks")
         self.assertEqual(
-            field.query_params, {"location": [self.locations[0].name, self.locations[1].name, self.locations[2].name]}
+            field.query_params,
+            {
+                "location": [self.locations[0].name, self.locations[1].name, self.locations[2].name],
+                "exclude_m2m": "true",
+            },
         )
 
         field = self.m2ms_1.to_form_field("peer")
         self.assertFalse(field.required)
         self.assertIsInstance(field, DynamicModelMultipleChoiceField)
-        self.assertEqual(field.query_params, {})
+        self.assertEqual(field.query_params, {"exclude_m2m": "true"})
 
     def test_to_form_field_o2m(self):
         field = self.o2m_1.to_form_field("source")
@@ -1326,7 +1343,7 @@ class RelationshipTableTest(RelationshipBaseTest, TestCase):
             self.assertIsNotNone(relationship_column)
             self.assertIsInstance(relationship_column, RelationshipColumn)
 
-            rendered_value = bound_row.get_cell(internal_col_name)
+            rendered_value = bound_row.get_cell(internal_col_name)  # pylint: disable=no-member
             # 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:
@@ -1432,7 +1449,7 @@ class RequiredRelationshipTestMixin:
             required_on="source",
         )
         relationship_o2o.validated_save()
-        vlan_group = VLANGroup.objects.first()
+        vlan_group = VLANGroup.objects.create(name="Test VLANGroup 1")
 
         tests_params = [
             # Required many-to-many:
@@ -1712,3 +1729,97 @@ class RequiredRelationshipTestMixin:
                         }
                     }
                     self.assertEqual(expected_error_json, response.json())
+
+
+class RelationshipJobTestCase(RequiredRelationshipTestMixin, TransactionTestCase):
+    databases = ("default", "job_logs")
+
+    def create_job(self, pk_list, **extra_form_data):
+        """"""
+        vlan_ct = ContentType.objects.get_for_model(VLAN)
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=vlan_ct.id,
+            edit_all=False,
+            filter_query_params={},
+            form_data={"pk": pk_list, **extra_form_data},
+            username=self.user.username,
+        )
+        return job_result
+
+    def test_required_relationships(self):
+        """
+        1. Try creating an object when no required target object exists
+        2. Try creating an object without specifying required target object(s)
+        3. Try creating an object when all required data is present
+        4. Test bulk edit
+        """
+
+        # Delete existing factory generated objects that may interfere with this test
+        IPAddress.objects.all().delete()
+        Prefix.objects.update(parent=None)
+        Prefix.objects.all().delete()
+        ControllerManagedDeviceGroupWirelessNetworkAssignment.objects.all().delete()
+        VLAN.objects.all().delete()
+
+        # Parameterized tests (for creating and updating single objects):
+        self.required_relationships_test(interact_with="ui")
+
+        # 4. Bulk create/edit tests:
+
+        vlan_status = Status.objects.get_for_model(VLAN).first()
+        vlans = (
+            VLAN.objects.create(name="test_required_relationships1", vid=1, status=vlan_status),
+            VLAN.objects.create(name="test_required_relationships2", vid=2, status=vlan_status),
+            VLAN.objects.create(name="test_required_relationships3", vid=3, status=vlan_status),
+            VLAN.objects.create(name="test_required_relationships4", vid=4, status=vlan_status),
+            VLAN.objects.create(name="test_required_relationships5", vid=5, status=vlan_status),
+            VLAN.objects.create(name="test_required_relationships6", vid=6, status=vlan_status),
+        )
+
+        # Try deleting all devices and then editing the 6 VLANs (fails):
+        Controller.objects.filter(controller_device__isnull=False).delete()
+        Device.objects.all().delete()
+
+        pk_list = [str(vlan.id) for vlan in vlans]
+        job_result = self.create_job(pk_list)
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertIn("VLANs require at least one device, but no devices exist yet.", error_log.message)
+
+        # Create test device for association
+        device_for_association = create_test_device("VLAN Required Device")
+
+        # Try editing all 6 VLANs without adding the required device(fails):
+        job_result = self.create_job(pk_list)
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertIn(
+            '6 VLANs require a device for the required relationship \\"VLANs require at least one Device',
+            error_log.message,
+        )
+
+        # Try editing 3 VLANs without adding the required device(fails):
+        job_result = self.create_job(pk_list[:3])
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertIn(
+            'These VLANs require a device for the required relationship \\"VLANs require at least one Device',
+            error_log.message,
+        )
+        for vlan in vlans[:3]:
+            self.assertIn(str(vlan), error_log.message)
+
+        # Try editing 6 VLANs and adding the required device (succeeds):
+        job_result = self.create_job(pk_list, add_cr_vlans_devices_m2m__source=[str(device_for_association.id)])
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+
+        # Try editing 6 VLANs and removing the required device (fails):
+        job_result = self.create_job(pk_list, remove_cr_vlans_devices_m2m__source=[str(device_for_association.id)])
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertIn(
+            '6 VLANs require a device for the required relationship \\"VLANs require at least one Device',
+            error_log.message,
+        )

nautobot/extras/tests/test_views.py

@@ -1,5 +1,4 @@
 from datetime import timedelta
-from http import HTTPStatus
 import json
 from unittest import mock
 import urllib.parse
@@ -26,7 +25,6 @@ from nautobot.core.testing.utils import disable_warnings, get_deletable_objects,
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.dcim.models import (
     ConsolePort,
-    Controller,
     Device,
     DeviceType,
     Interface,
@@ -34,7 +32,6 @@ from nautobot.dcim.models import (
     LocationType,
     Manufacturer,
 )
-from nautobot.dcim.tests import test_views
 from nautobot.extras.choices import (
     CustomFieldTypeChoices,
     DynamicGroupTypeChoices,
@@ -89,10 +86,9 @@ from nautobot.extras.templatetags.job_buttons import NO_CONFIRM_BUTTON
 from nautobot.extras.tests.constants import BIG_GRAPHQL_DEVICE_QUERY
 from nautobot.extras.tests.test_relationships import RequiredRelationshipTestMixin
 from nautobot.extras.utils import RoleModelsQuery, TaggableClassesQuery
-from nautobot.ipam.models import IPAddress, Prefix, VLAN, VLANGroup
+from nautobot.ipam.models import IPAddress, Prefix, VLAN, VLANGroup, VRF
 from nautobot.tenancy.models import Tenant
 from nautobot.users.models import ObjectPermission
-from nautobot.wireless.models import ControllerManagedDeviceGroupWirelessNetworkAssignment
 
 # Use the proper swappable User model
 User = get_user_model()
@@ -915,6 +911,30 @@ class DynamicGroupTestCase(
         self.form_data["content_type"] = instance.content_type.pk  # Content-type is not editable after creation
         super().test_edit_object_with_constrained_permission()
 
+    def test_edit_object_with_content_type_ipam_prefix(self):
+        """Assert bug fix #6526: `Error when defining Dynamic Group of Prefixes using `present_in_vrf_id` filter`"""
+        content_type = ContentType.objects.get_for_model(Prefix)
+        instance = DynamicGroup.objects.create(name="DG Ipam|Prefix", content_type=content_type)
+        vrf_instance = VRF.objects.first()
+        data = self.form_data.copy()
+        data.update(
+            {
+                "name": "DG Ipam|Prefix",
+                "content_type": content_type.pk,
+                "filter-present_in_vrf_id": vrf_instance.id,
+                "tenant": None,
+                "tags": [],
+            }
+        )
+        self.add_permissions("extras.change_dynamicgroup")
+        request = {
+            "path": self._get_url("edit", instance),
+            "data": post_data(data),
+        }
+        self.assertHttpStatus(self.client.post(**request), 302)
+        instance.refresh_from_db()
+        self.assertEqual(instance.filter["present_in_vrf_id"], str(vrf_instance.id))
+
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_edit_saved_filter(self):
         """Test that editing a filter works using the edit view."""
@@ -1698,21 +1718,21 @@ class ScheduledJobTestCase(
         user = User.objects.create(username="user1", is_active=True)
         ScheduledJob.objects.create(
             name="test1",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             interval=JobExecutionType.TYPE_IMMEDIATELY,
             user=user,
             start_time=timezone.now(),
         )
         ScheduledJob.objects.create(
             name="test2",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             interval=JobExecutionType.TYPE_DAILY,
             user=user,
             start_time=timezone.now(),
         )
         ScheduledJob.objects.create(
             name="test3",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             interval=JobExecutionType.TYPE_CUSTOM,
             user=user,
             start_time=timezone.now(),
@@ -1726,7 +1746,7 @@ class ScheduledJobTestCase(
         ScheduledJob.objects.create(
             enabled=False,
             name="test4",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             interval=JobExecutionType.TYPE_IMMEDIATELY,
             user=self.user,
             start_time=timezone.now(),
@@ -1743,7 +1763,7 @@ class ScheduledJobTestCase(
             ScheduledJob.objects.create(
                 enabled=True,
                 name=name,
-                task="pass.TestPass",
+                task="pass.TestPassJob",
                 interval=JobExecutionType.TYPE_CUSTOM,
                 user=self.user,
                 start_time=timezone.now(),
@@ -1774,7 +1794,7 @@ class ScheduledJobTestCase(
         ScheduledJob.objects.create(
             enabled=True,
             name="test11",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             interval=JobExecutionType.TYPE_CUSTOM,
             user=self.user,
             start_time=timezone.now(),
@@ -1808,7 +1828,7 @@ class ApprovalQueueTestCase(
     def setUp(self):
         super().setUp()
         self.job_model = Job.objects.get_for_class_path("dry_run.TestDryRun")
-        self.job_model_2 = Job.objects.get_for_class_path("fail.TestFail")
+        self.job_model_2 = Job.objects.get_for_class_path("fail.TestFailJob")
 
         ScheduledJob.objects.create(
             name="test1",
@@ -1821,7 +1841,7 @@ class ApprovalQueueTestCase(
         )
         ScheduledJob.objects.create(
             name="test2",
-            task="fail.TestFail",
+            task="fail.TestFailJob",
             job_model=self.job_model_2,
             interval=JobExecutionType.TYPE_IMMEDIATELY,
             user=self.user,
@@ -1834,7 +1854,7 @@ class ApprovalQueueTestCase(
 
         ScheduledJob.objects.create(
             name="test4",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             job_model=self.job_model,
             interval=JobExecutionType.TYPE_IMMEDIATELY,
             user=self.user,
@@ -2225,8 +2245,8 @@ class JobResultTestCase(
 
     @classmethod
     def setUpTestData(cls):
-        JobResult.objects.create(name="pass.TestPass")
-        JobResult.objects.create(name="fail.TestFail")
+        JobResult.objects.create(name="pass.TestPassJob")
+        JobResult.objects.create(name="fail.TestFailJob")
         JobLogEntry.objects.create(
             log_level=LogLevelChoices.LOG_INFO,
             job_result=JobResult.objects.first(),
@@ -2280,7 +2300,7 @@ class JobTestCase(
         # 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.test_pass = Job.objects.get(job_class_name="TestPass")
+        cls.test_pass = Job.objects.get(job_class_name="TestPassJob")
         default_job_queue = JobQueue.objects.get(name="default", queue_type=JobQueueTypeChoices.TYPE_CELERY)
         cls.test_pass.default_job_queue = default_job_queue
         cls.test_pass.enabled = True
@@ -2416,35 +2436,6 @@ class JobTestCase(
         # assert Job still exists
         self.assertTrue(self._get_queryset().filter(name=job_name).exists())
 
-    def test_bulk_delete_system_jobs_fail(self):
-        system_job_queryset = self.model.objects.filter(module_name__startswith="nautobot.")
-        pk_list = system_job_queryset.values_list("pk", flat=True)[:3]
-        initial_count = self._get_queryset().count()
-        data = {
-            "pk": pk_list,
-            "confirm": True,
-            "_confirm": True,  # Form button
-        }
-        # Try bulk delete with delete job permission
-        self.add_permissions("extras.delete_job")
-        response = self.client.post(self._get_url("bulk_delete"), data, follow=True)
-        self.assertBodyContains(
-            response,
-            f"Unable to delete Job {system_job_queryset.first()}. System Job cannot be deleted",
-            status_code=403,
-        )
-        self.assertEqual(self._get_queryset().count(), initial_count)
-
-        # Try bulk delete as a superuser
-        self.user.is_superuser = True
-        response = self.client.post(self._get_url("bulk_delete"), data, follow=True)
-        self.assertBodyContains(
-            response,
-            f"Unable to delete Job {system_job_queryset.first()}. System Job cannot be deleted",
-            status_code=403,
-        )
-        self.assertEqual(self._get_queryset().count(), initial_count)
-
     def validate_job_data_after_bulk_edit(self, pk_list, old_data):
         # Name is bulk-editable
         overridable_fields = [field for field in JOB_OVERRIDABLE_FIELDS if field != "name"]
@@ -2513,7 +2504,7 @@ class JobTestCase(
         self.add_permissions("extras.run_job")
         for run_url in self.run_urls:
             response = self.client.get(run_url)
-            self.assertBodyContains(response, "TestPass")
+            self.assertBodyContains(response, "TestPassJob")
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
     def test_get_run_with_constrained_permission(self):
@@ -2612,12 +2603,12 @@ class JobTestCase(
         self.add_permissions("extras.run_job")
 
         for run_url in (
-            reverse("extras:job_run_by_class_path", kwargs={"class_path": "fail.TestFail"}),
-            reverse("extras:job_run", kwargs={"pk": Job.objects.get(job_class_name="TestFail").pk}),
+            reverse("extras:job_run_by_class_path", kwargs={"class_path": "fail.TestFailJob"}),
+            reverse("extras:job_run", kwargs={"pk": Job.objects.get(job_class_name="TestFailJob").pk}),
         ):
             response = self.client.post(run_url, self.data_run_immediately)
             self.assertBodyContains(response, "Job is not enabled to be run")
-            self.assertFalse(JobResult.objects.filter(name="fail.TestFail").exists())
+            self.assertFalse(JobResult.objects.filter(name="fail.TestFailJob").exists())
 
     def test_run_now_missing_args(self):
         self.add_permissions("extras.run_job")
@@ -2653,10 +2644,16 @@ class JobTestCase(
         job_celery_kwargs = {
             "nautobot_job_job_model_id": self.test_required_args.id,
             "nautobot_job_profile": True,
+            "nautobot_job_ignore_singleton_lock": True,
             "nautobot_job_user_id": self.user.id,
             "queue": job_queue.name,
         }
         self.test_required_args.job_queues.set([job_queue])
+        self.test_required_args.is_singleton_override = True
+        self.test_required_args.has_sensitive_variables_override = True
+        self.test_required_args.is_singleton = True
+        self.test_required_args.has_sensitive_variables = False
+        self.test_required_args.validated_save()
         previous_result = JobResult.objects.create(
             job_model=self.test_required_args,
             user=self.user,
@@ -2673,6 +2670,9 @@ class JobTestCase(
             content,
         )
         self.assertInHTML('<input type="hidden" name="_profile" value="True" id="id__profile">', content)
+        self.assertInHTML(
+            '<input type="checkbox" name="_ignore_singleton_lock" id="id__ignore_singleton_lock" checked>', content
+        )
 
     @mock.patch("nautobot.extras.views.get_worker_count", return_value=1)
     def test_run_later_missing_name(self, _):
@@ -2844,59 +2844,6 @@ class JobTestCase(
         response = self.client.get(instance.get_changelog_url())
         self.assertBodyContains(response, f"{instance.name} - Change Log")
 
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
-    def test_job_bulk_edit_default_queue_stays_default_after_one_field_update(self):
-        self.add_permissions("extras.change_job")
-        job_class_to_test = "TestPass"
-        job_description = "default job queue test"
-        job_to_test = self.model.objects.get(job_class_name=job_class_to_test)
-        queryset = self.model.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))
-
-        data = {
-            "description": job_description,
-            "pk": pk_list,
-            "_apply": True,
-        }
-
-        self.assertHttpStatus(self.client.post(self._get_url("bulk_edit"), data), HTTPStatus.FOUND)
-        instance = self.model.objects.get(job_class_name=job_class_to_test)
-        self.assertEqual(instance.description, job_description)
-        self.assertEqual(instance.default_job_queue, default_job_queue)
-
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
-    def test_job_bulk_edit_preserve_job_queues_after_one_field_update(self):
-        self.add_permissions("extras.change_job")
-        job_class_to_test = "TestPass"
-        job_description = "job queues test"
-        job_to_test = self.model.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 = self.model.objects.filter(installed=True, hidden=False, job_class_name=job_class_to_test)
-        pk_list = list(queryset.values_list("pk", flat=True))
-
-        data = {
-            "description": job_description,
-            "pk": pk_list,
-            "_apply": True,
-        }
-
-        self.assertHttpStatus(self.client.post(self._get_url("bulk_edit"), data), HTTPStatus.FOUND)
-
-        instance = self.model.objects.get(job_class_name=job_class_to_test)
-        self.assertEqual(instance.description, job_description)
-        self.assertEqual(instance.job_queues.count(), 4)  # 3 custom one + 1 default
-        self.assertQuerySetEqual(instance.job_queues.all(), JobQueue.objects.filter(pk__in=expected_job_queues))
-
 
 class JobButtonTestCase(
     ViewTestCases.CreateObjectViewTestCase,
@@ -3008,8 +2955,9 @@ class JobButtonRenderingTestCase(TestCase):
         response = self.client.get(self.location_type.get_absolute_url(), follow=True)
         self.assertEqual(response.status_code, 200)
         content = extract_page_body(response.content.decode(response.charset))
-        job_queues = self.job.job_queues.all().values_list("name", flat=True)
-        self.assertIn(f'<input type="hidden" name="_job_queue" value="{job_queues[0]}">', content, content)
+        job_queues = self.job.job_queues.all()
+        _job_queue = job_queues[0]
+        self.assertIn(f'<input type="hidden" name="_job_queue" value="{_job_queue.pk}">', content, content)
 
         self.job.job_queues_override = False
         self.job.save()
@@ -3018,7 +2966,7 @@ class JobButtonRenderingTestCase(TestCase):
         self.assertEqual(response.status_code, 200)
         content = extract_page_body(response.content.decode(response.charset))
         self.assertIn(
-            f'<input type="hidden" name="_job_queue" value="{self.job.default_job_queue.name}">', content, content
+            f'<input type="hidden" name="_job_queue" value="{self.job.default_job_queue.pk}">', content, content
         )
 
     def test_view_object_with_unsafe_text(self):
@@ -3279,94 +3227,6 @@ class RelationshipTestCase(
 
         cls.slug_test_object = "Primary Interface"
 
-    def test_required_relationships(self):
-        """
-        1. Try creating an object when no required target object exists
-        2. Try creating an object without specifying required target object(s)
-        3. Try creating an object when all required data is present
-        4. Test bulk edit
-        """
-
-        # Delete existing factory generated objects that may interfere with this test
-        IPAddress.objects.all().delete()
-        Prefix.objects.update(parent=None)
-        Prefix.objects.all().delete()
-        ControllerManagedDeviceGroupWirelessNetworkAssignment.objects.all().delete()
-        VLAN.objects.all().delete()
-
-        # Parameterized tests (for creating and updating single objects):
-        self.required_relationships_test(interact_with="ui")
-
-        # 4. Bulk create/edit tests:
-
-        vlan_status = Status.objects.get_for_model(VLAN).first()
-        vlans = (
-            VLAN.objects.create(name="test_required_relationships1", vid=1, status=vlan_status),
-            VLAN.objects.create(name="test_required_relationships2", vid=2, status=vlan_status),
-            VLAN.objects.create(name="test_required_relationships3", vid=3, status=vlan_status),
-            VLAN.objects.create(name="test_required_relationships4", vid=4, status=vlan_status),
-            VLAN.objects.create(name="test_required_relationships5", vid=5, status=vlan_status),
-            VLAN.objects.create(name="test_required_relationships6", vid=6, status=vlan_status),
-        )
-
-        # Try deleting all devices and then editing the 6 VLANs (fails):
-        Controller.objects.filter(controller_device__isnull=False).delete()
-        Device.objects.all().delete()
-        response = self.client.post(
-            reverse("ipam:vlan_bulk_edit"), data={"pk": [str(vlan.id) for vlan in vlans], "_apply": [""]}
-        )
-        self.assertContains(response, "VLANs require at least one device, but no devices exist yet.")
-
-        # Create test device for association
-        device_for_association = test_views.create_test_device("VLAN Required Device")
-
-        # Try editing all 6 VLANs without adding the required device(fails):
-        response = self.client.post(
-            reverse("ipam:vlan_bulk_edit"), data={"pk": [str(vlan.id) for vlan in vlans], "_apply": [""]}
-        )
-        self.assertContains(
-            response,
-            "6 VLANs require a device for the required relationship &quot;VLANs require at least one Device&quot;",
-        )
-
-        # Try editing 3 VLANs without adding the required device(fails):
-        response = self.client.post(
-            reverse("ipam:vlan_bulk_edit"), data={"pk": [str(vlan.id) for vlan in vlans[:3]], "_apply": [""]}
-        )
-        self.assertContains(
-            response,
-            "These VLANs require a device for the required "
-            "relationship &quot;VLANs require at least one Device&quot;",
-        )
-        for vlan in vlans[:3]:
-            self.assertContains(response, str(vlan))
-
-        # Try editing 6 VLANs and adding the required device (succeeds):
-        response = self.client.post(
-            reverse("ipam:vlan_bulk_edit"),
-            data={
-                "pk": [str(vlan.id) for vlan in vlans],
-                "add_cr_vlans_devices_m2m__source": [str(device_for_association.id)],
-                "_apply": [""],
-            },
-            follow=True,
-        )
-        self.assertContains(response, "Updated 6 VLANs")
-
-        # Try editing 6 VLANs and removing the required device (fails):
-        response = self.client.post(
-            reverse("ipam:vlan_bulk_edit"),
-            data={
-                "pk": [str(vlan.id) for vlan in vlans],
-                "remove_cr_vlans_devices_m2m__source": [str(device_for_association.id)],
-                "_apply": [""],
-            },
-        )
-        self.assertContains(
-            response,
-            "6 VLANs require a device for the required relationship &quot;VLANs require at least one Device&quot;",
-        )
-
 
 class RelationshipAssociationTestCase(
     # TODO? ViewTestCases.CreateObjectViewTestCase,
@@ -3749,6 +3609,8 @@ class RoleTestCase(ViewTestCases.OrganizationalObjectViewTestCase):
 
         cls.bulk_edit_data = {
             "color": "000000",
+            "description": "I used to be a new role object.",
+            "weight": 255,
         }
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])

nautobot/extras/utils.py

@@ -579,6 +579,7 @@ def refresh_job_model_from_job_class(job_model_class, job_class, job_queue_class
                     "installed": True,
                     "enabled": False,
                     "default_job_queue": default_job_queue,
+                    "is_singleton": job_class.is_singleton,
                 },
             )
 
@@ -665,9 +666,9 @@ def run_kubernetes_job_and_return_job_result(job_queue, job_result, job_kwargs):
         "runjob_with_job_result",
         f"{job_result.pk}",
     ]
-    logger.info("Creating job pod %s in namespace %s", pod_name, pod_namespace)
+    job_result.log(f"Creating job pod {pod_name} in namespace {pod_namespace}")
     api_instance.create_namespaced_job(body=pod_manifest, namespace=pod_namespace)
-    logger.info("Reading job pod %s in namespace %s", pod_name, pod_namespace)
+    job_result.log(f"Reading job pod {pod_name} in namespace {pod_namespace}")
     api_instance.read_namespaced_job(name="nautobot-job-" + str(job_result.pk), namespace=pod_namespace)
     return job_result