nautobot 2.4.0__py3-none-any.whl → 2.4.0b1__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 create_job_result_and_run_job, TestCase, TransactionTestCase
+from nautobot.core.testing import TestCase
 from nautobot.core.testing.models import ModelTestCases
 from nautobot.core.utils.lookup import get_route_for_model
 from nautobot.dcim.forms import DeviceForm
@@ -29,22 +29,9 @@ 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 (
-    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
+from nautobot.extras.choices import RelationshipRequiredSideChoices, RelationshipSideChoices, RelationshipTypeChoices
+from nautobot.extras.models import Relationship, RelationshipAssociation, Role, Status
+from nautobot.ipam.models import VLAN, VLANGroup
 
 
 class RelationshipBaseTest:
@@ -367,24 +354,20 @@ class RelationshipTest(RelationshipBaseTest, ModelTestCases.BaseModelTestCase):
         self.assertFalse(field.required)
         self.assertIsInstance(field, DynamicModelMultipleChoiceField)
         self.assertEqual(field.label, "My VLANs")
-        self.assertEqual(field.query_params, {"exclude_m2m": "true"})
+        self.assertEqual(field.query_params, {})
 
         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],
-                "exclude_m2m": "true",
-            },
+            field.query_params, {"location": [self.locations[0].name, self.locations[1].name, self.locations[2].name]}
         )
 
         field = self.m2ms_1.to_form_field("peer")
         self.assertFalse(field.required)
         self.assertIsInstance(field, DynamicModelMultipleChoiceField)
-        self.assertEqual(field.query_params, {"exclude_m2m": "true"})
+        self.assertEqual(field.query_params, {})
 
     def test_to_form_field_o2m(self):
         field = self.o2m_1.to_form_field("source")
@@ -1343,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:
@@ -1449,7 +1432,7 @@ class RequiredRelationshipTestMixin:
             required_on="source",
         )
         relationship_o2o.validated_save()
-        vlan_group = VLANGroup.objects.create(name="Test VLANGroup 1")
+        vlan_group = VLANGroup.objects.first()
 
         tests_params = [
             # Required many-to-many:
@@ -1729,97 +1712,3 @@ 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,4 +1,5 @@
 from datetime import timedelta
+from http import HTTPStatus
 import json
 from unittest import mock
 import urllib.parse
@@ -25,6 +26,7 @@ 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,
@@ -32,6 +34,7 @@ from nautobot.dcim.models import (
     LocationType,
     Manufacturer,
 )
+from nautobot.dcim.tests import test_views
 from nautobot.extras.choices import (
     CustomFieldTypeChoices,
     DynamicGroupTypeChoices,
@@ -86,9 +89,10 @@ 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, VRF
+from nautobot.ipam.models import IPAddress, Prefix, VLAN, VLANGroup
 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()
@@ -911,30 +915,6 @@ 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."""
@@ -1718,21 +1698,21 @@ class ScheduledJobTestCase(
         user = User.objects.create(username="user1", is_active=True)
         ScheduledJob.objects.create(
             name="test1",
-            task="pass.TestPassJob",
+            task="pass.TestPass",
             interval=JobExecutionType.TYPE_IMMEDIATELY,
             user=user,
             start_time=timezone.now(),
         )
         ScheduledJob.objects.create(
             name="test2",
-            task="pass.TestPassJob",
+            task="pass.TestPass",
             interval=JobExecutionType.TYPE_DAILY,
             user=user,
             start_time=timezone.now(),
         )
         ScheduledJob.objects.create(
             name="test3",
-            task="pass.TestPassJob",
+            task="pass.TestPass",
             interval=JobExecutionType.TYPE_CUSTOM,
             user=user,
             start_time=timezone.now(),
@@ -1746,7 +1726,7 @@ class ScheduledJobTestCase(
         ScheduledJob.objects.create(
             enabled=False,
             name="test4",
-            task="pass.TestPassJob",
+            task="pass.TestPass",
             interval=JobExecutionType.TYPE_IMMEDIATELY,
             user=self.user,
             start_time=timezone.now(),
@@ -1763,7 +1743,7 @@ class ScheduledJobTestCase(
             ScheduledJob.objects.create(
                 enabled=True,
                 name=name,
-                task="pass.TestPassJob",
+                task="pass.TestPass",
                 interval=JobExecutionType.TYPE_CUSTOM,
                 user=self.user,
                 start_time=timezone.now(),
@@ -1794,7 +1774,7 @@ class ScheduledJobTestCase(
         ScheduledJob.objects.create(
             enabled=True,
             name="test11",
-            task="pass.TestPassJob",
+            task="pass.TestPass",
             interval=JobExecutionType.TYPE_CUSTOM,
             user=self.user,
             start_time=timezone.now(),
@@ -1828,7 +1808,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.TestFailJob")
+        self.job_model_2 = Job.objects.get_for_class_path("fail.TestFail")
 
         ScheduledJob.objects.create(
             name="test1",
@@ -1841,7 +1821,7 @@ class ApprovalQueueTestCase(
         )
         ScheduledJob.objects.create(
             name="test2",
-            task="fail.TestFailJob",
+            task="fail.TestFail",
             job_model=self.job_model_2,
             interval=JobExecutionType.TYPE_IMMEDIATELY,
             user=self.user,
@@ -1854,7 +1834,7 @@ class ApprovalQueueTestCase(
 
         ScheduledJob.objects.create(
             name="test4",
-            task="pass.TestPassJob",
+            task="pass.TestPass",
             job_model=self.job_model,
             interval=JobExecutionType.TYPE_IMMEDIATELY,
             user=self.user,
@@ -2245,8 +2225,8 @@ class JobResultTestCase(
 
     @classmethod
     def setUpTestData(cls):
-        JobResult.objects.create(name="pass.TestPassJob")
-        JobResult.objects.create(name="fail.TestFailJob")
+        JobResult.objects.create(name="pass.TestPass")
+        JobResult.objects.create(name="fail.TestFail")
         JobLogEntry.objects.create(
             log_level=LogLevelChoices.LOG_INFO,
             job_result=JobResult.objects.first(),
@@ -2300,7 +2280,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="TestPassJob")
+        cls.test_pass = Job.objects.get(job_class_name="TestPass")
         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
@@ -2436,6 +2416,35 @@ 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"]
@@ -2504,7 +2513,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, "TestPassJob")
+            self.assertBodyContains(response, "TestPass")
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
     def test_get_run_with_constrained_permission(self):
@@ -2603,12 +2612,12 @@ class JobTestCase(
         self.add_permissions("extras.run_job")
 
         for run_url in (
-            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}),
+            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}),
         ):
             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.TestFailJob").exists())
+            self.assertFalse(JobResult.objects.filter(name="fail.TestFail").exists())
 
     def test_run_now_missing_args(self):
         self.add_permissions("extras.run_job")
@@ -2644,16 +2653,10 @@ 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,
@@ -2670,9 +2673,6 @@ 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,6 +2844,59 @@ 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,
@@ -3226,6 +3279,94 @@ 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,
@@ -3608,8 +3749,6 @@ 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,7 +579,6 @@ 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,
                 },
             )
 
@@ -666,9 +665,9 @@ def run_kubernetes_job_and_return_job_result(job_queue, job_result, job_kwargs):
         "runjob_with_job_result",
         f"{job_result.pk}",
     ]
-    job_result.log(f"Creating job pod {pod_name} in namespace {pod_namespace}")
+    logger.info("Creating job pod %s in namespace %s", pod_name, pod_namespace)
     api_instance.create_namespaced_job(body=pod_manifest, namespace=pod_namespace)
-    job_result.log(f"Reading job pod {pod_name} in namespace {pod_namespace}")
+    logger.info("Reading job pod %s in namespace %s", pod_name, pod_namespace)
     api_instance.read_namespaced_job(name="nautobot-job-" + str(job_result.pk), namespace=pod_namespace)
     return job_result