nautobot 2.3.4__py3-none-any.whl → 2.3.5__py3-none-any.whl

nautobot/core/tests/runner.py

@@ -64,9 +64,16 @@ class NautobotTestRunner(DiscoverRunner):
             action="store_true",
             help="Save test database to a json fixture file to re-use on subsequent tests.",
         )
+        parser.add_argument(
+            "--no-reusedb",
+            action="store_false",
+            dest="reusedb",
+            help="Supplement to --keepdb; if --no-reusedb is set an existing database will NOT be reused.",
+        )
 
-    def __init__(self, cache_test_fixtures=False, **kwargs):
+    def __init__(self, cache_test_fixtures=False, reusedb=True, **kwargs):
         self.cache_test_fixtures = cache_test_fixtures
+        self.reusedb = reusedb
 
         # Assert "integration" hasn't been provided w/ --tag
         incoming_tags = kwargs.get("tags") or []
@@ -118,7 +125,9 @@ class NautobotTestRunner(DiscoverRunner):
                         connection.creation.create_test_db(
                             verbosity=self.verbosity,
                             autoclobber=not self.interactive,
-                            keepdb=self.keepdb,
+                            keepdb=self.keepdb
+                            # Extra check added for Nautobot:
+                            and self.reusedb,
                             serialize=connection.settings_dict["TEST"].get("SERIALIZE", True),
                         )
 
@@ -149,7 +158,7 @@ class NautobotTestRunner(DiscoverRunner):
                                     verbosity=self.verbosity,
                                     keepdb=self.keepdb
                                     # Extra check added for Nautobot:
-                                    and not settings.TEST_USE_FACTORIES,
+                                    and self.reusedb,
                                 )
 
                 # Configure all other connections as mirrors of the first one
@@ -179,9 +188,7 @@ class NautobotTestRunner(DiscoverRunner):
                         connection.creation.destroy_test_db(
                             suffix=str(index + 1),
                             verbosity=self.verbosity,
-                            keepdb=self.keepdb
-                            # Extra check added for Nautobot
-                            and not settings.TEST_USE_FACTORIES,
+                            keepdb=self.keepdb,
                         )
 
                 # Extra block added for Nautobot

nautobot/core/tests/test_views.py

@@ -1,8 +1,9 @@
 import re
-from unittest import mock
+from unittest import mock, skipIf
 import urllib.parse
 
 from django.apps import apps
+from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.test import override_settings, RequestFactory
@@ -572,3 +573,41 @@ class SilkUIAccessTestCase(TestCase):
 
         # Check for success status code (e.g., 200)
         self.assertEqual(response.status_code, 200)
+
+
+class ExampleViewWithCustomPermissionsTest(TestCase):
+    @skipIf(
+        "example_app" not in settings.PLUGINS,
+        "example_app not in settings.PLUGINS",
+    )
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
+    def test_permission_classes_attribute_is_enforced(self):
+        """
+        If example app is installed, check if the ViewWithCustomPermissions
+        is enforcing the permissions specified in its `permission_classes` attribute.
+        """
+        # Test IsAuthenticated permission
+        self.add_permissions("example_app.view_examplemodel")
+        self.client.logout()
+        url = reverse("plugins:example_app:view_with_custom_permissions")
+        response = self.client.get(url, follow=True)
+        self.assertHttpStatus(response, 200)
+        response_body = response.content.decode(response.charset)
+        # check if the user is redirected to the login page
+        self.assertIn(f'<input type="hidden" name="next" value="{url}" />', response_body)
+
+        # Test IsAdmin permission
+        self.client.force_login(self.user)
+        response = self.client.get(url, follow=True)
+        self.assertHttpStatus(response, 403)
+        response_body = response.content.decode(response.charset)
+        # check if the users have to have the permission to access the page
+        self.assertIn("You do not have permission to access this page.", response_body)
+
+        # View should be successfully accessed
+        self.user.is_staff = True
+        self.user.save()
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 200)
+        response_body = response.content.decode(response.charset)
+        self.assertIn("You are viewing a table of example models", response_body)

nautobot/core/views/generic.py

@@ -17,7 +17,7 @@ from django.db.models import ManyToManyField, ProtectedError, Q
 from django.forms import Form, ModelMultipleChoiceField, MultipleHiddenInput
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404, redirect, render
-from django.urls import reverse
+from django.urls import resolve, reverse
 from django.utils.encoding import iri_to_uri
 from django.utils.html import format_html
 from django.utils.http import url_has_allowed_host_and_scheme
@@ -205,17 +205,16 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
         filter_form = None
         hide_hierarchy_ui = False
         clear_view = request.GET.get("clear_view", False)
+        resolved_path = resolve(request.path)
+        list_url = f"{resolved_path.app_name}:{resolved_path.url_name}"
 
         # If the user clicks on the clear view button, we do not check for global or user defaults
         if not clear_view and not request.GET.get("saved_view"):
             # Check if there is a default for this view for this specific user
-            app_label, model_name = model._meta.label.split(".")
-            view_name = f"{app_label}:{model_name.lower()}_list"
-
             if not isinstance(user, AnonymousUser):
                 try:
                     user_default_saved_view_pk = UserSavedViewAssociation.objects.get(
-                        user=user, view_name=view_name
+                        user=user, view_name=list_url
                     ).saved_view.pk
                     # Saved view should either belong to the user or be public
                     SavedView.objects.get(
@@ -229,7 +228,7 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
 
             # Check if there is a global default for this view
             try:
-                global_saved_view = SavedView.objects.get(view=view_name, is_global_default=True)
+                global_saved_view = SavedView.objects.get(view=list_url, is_global_default=True)
                 return redirect(reverse("extras:savedview", kwargs={"pk": global_saved_view.pk}))
             except ObjectDoesNotExist:
                 pass
@@ -302,7 +301,6 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
         table_config_form = None
         current_saved_view = None
         current_saved_view_pk = self.request.GET.get("saved_view", None)
-        list_url = validated_viewname(model, "list")
         # We are not using .restrict(request.user, "view") here
         # User should be able to see any saved view that he has the list view access to.
         if user.has_perms(["extras.view_savedview"]):
@@ -315,15 +313,17 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
                 SavedView.objects.filter(view=list_url, owner=user).order_by("name").only("pk", "name")
             )
             saved_views = shared_saved_views | user_owned_saved_views
+
+        if current_saved_view_pk:
+            try:
+                # We are not using .restrict(request.user, "view") here
+                # User should be able to see any saved view that he has the list view access to.
+                current_saved_view = SavedView.objects.get(view=list_url, pk=current_saved_view_pk)
+            except ObjectDoesNotExist:
+                messages.error(request, f"Saved view {current_saved_view_pk} not found")
+
+        # Construct the objects table
         if self.table:
-            # Construct the objects table
-            if current_saved_view_pk:
-                try:
-                    # We are not using .restrict(request.user, "view") here
-                    # User should be able to see any saved view that he has the list view access to.
-                    current_saved_view = SavedView.objects.get(view=list_url, pk=current_saved_view_pk)
-                except ObjectDoesNotExist:
-                    messages.error(request, f"Saved view {current_saved_view_pk} not found")
             if self.request.GET.getlist("sort") or (
                 current_saved_view is not None and current_saved_view.config.get("sort_order")
             ):

nautobot/core/views/mixins.py

@@ -234,6 +234,7 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
     serializer_class = None
     table_class = None
     notes_form_class = NoteForm
+    permission_classes = []
 
     def get_permissions_for_model(self, model, actions):
         """
@@ -267,7 +268,7 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
         """
         user = self.request.user
         permission_required = self.get_required_permission()
-        # Check that the user has been granted the required permission(s) one by one.
+        # Check that the user has been granted the required Nautobot-specific object permission(s) one by one.
         # In case the permission has `message` or `code`` attribute, we want to include those information in the permission_denied error.
         for permission in permission_required:
             # If the user does not have the permission required, we raise DRF's `NotAuthenticated` or `PermissionDenied` exception
@@ -280,6 +281,16 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
                     code=getattr(permission, "code", None),
                 )
 
+        # Check for drf-specific permissions (IsAutheticated, etc) in permission_classes which is empty by default.
+        # self.get_permissions() iterates through permissions specified in the `permission_classes` attribute.
+        for permission in self.get_permissions():
+            # If the user does not have the permission required, we raise DRF's `NotAuthenticated` or `PermissionDenied` exception
+            # which will be handled by self.handle_no_permission() in the UI appropriately in the dispatch() method
+            if not permission.has_permission(request, self):
+                self.permission_denied(
+                    request, message=getattr(permission, "message", None), code=getattr(permission, "code", None)
+                )
+
     def dispatch(self, request, *args, **kwargs):
         """
         Override the default dispatch() method to check permissions first.

nautobot/core/views/renderers.py

@@ -5,6 +5,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ObjectDoesNotExist
 from django.db.models import Q
 from django.template import engines, loader
+from django.urls import resolve
 from django_tables2 import RequestConfig
 from rest_framework import renderers
 
@@ -295,7 +296,8 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
             # Construct valid actions for list view.
             valid_actions = self.validate_action_buttons(view, request)
             # Query SavedViews for dropdown button
-            list_url = validated_viewname(model, "list")
+            resolved_path = resolve(request.path)
+            list_url = f"{resolved_path.app_name}:{resolved_path.url_name}"
             saved_views = None
             if model.is_saved_view_model:
                 # We are not using .restrict(request.user, "view") here

nautobot/core/views/utils.py

@@ -213,7 +213,7 @@ def handle_protectederror(obj_list, request, e):
     protected_objects = list(e.protected_objects)
     protected_count = len(protected_objects) if len(protected_objects) <= 50 else "More than 50"
     err_message = format_html(
-        "Unable to delete <strong>{}</strong>. {} dependent objects were found: ",
+        str(e.args[0]) if e.args else "Unable to delete <strong>{}</strong>. {} dependent objects were found: ",
         ", ".join(str(obj) for obj in obj_list),
         protected_count,
     )

nautobot/dcim/api/serializers.py

@@ -389,6 +389,7 @@ class RackElevationDetailFilterSerializer(serializers.Serializer):
     expand_devices = serializers.BooleanField(required=False, default=True)
     include_images = serializers.BooleanField(required=False, default=True)
     display_fullname = serializers.BooleanField(required=False, default=True)
+    is_occupied = serializers.BooleanField(required=False, allow_null=True, default=None)
 
     def validate(self, attrs):
         attrs.setdefault("unit_width", get_settings_or_config("RACK_ELEVATION_DEFAULT_UNIT_WIDTH"))

nautobot/dcim/api/views.py

@@ -231,6 +231,8 @@ class RackViewSet(NautobotModelViewSet):
                 exclude=data["exclude"],
                 expand_devices=data["expand_devices"],
             )
+            if data["is_occupied"] is not None:
+                elevation = [u for u in elevation if u["occupied"] == data["is_occupied"]]
 
             # Enable filtering rack units by ID
             q = data["q"]

nautobot/dcim/forms.py

@@ -1900,7 +1900,7 @@ class DeviceForm(LocatableModelFormMixin, NautobotModelForm, TenancyForm, LocalC
         widget=APISelect(
             api_url="/api/dcim/racks/{{rack}}/elevation/",
             attrs={
-                "disabled-indicator": "device",
+                "disabled-indicator": "occupied",
                 "data-query-param-face": '["$face"]',
             },
         ),

nautobot/dcim/templates/dcim/devicefamily_retrieve.html

@@ -16,7 +16,7 @@
                 </tr>
                 <tr>
                     <td>Device Types</td>
-                    <td><a href="{% url 'dcim:devicetype_list' %}?device_family={{ object.name }}">{{ object.device_type_count }}</a></td>
+                    <td><a href="{% url 'dcim:devicetype_list' %}?device_family={{ object.name }}">{{ device_type_count }}</a></td>
                 </tr>
                 <tr>
                     <td>Total Devices</td>

nautobot/dcim/tests/test_api.py

@@ -139,7 +139,7 @@ class Mixins:
             super().setUpTestData()
             cls.device_type = DeviceType.objects.first()
             cls.manufacturer = cls.device_type.manufacturer
-            cls.location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
+            cls.location = Location.objects.filter(location_type__name="Campus").first()
             cls.device_role = Role.objects.get_for_model(Device).first()
             cls.device_status = Status.objects.get_for_model(Device).first()
             cls.device = Device.objects.create(
@@ -539,6 +539,8 @@ class RackGroupTest(APIViewTestCases.APIViewTestCase, APIViewTestCases.TreeModel
     def setUpTestData(cls):
         cls.status = Status.objects.get_for_model(Location).first()
         location_type = LocationType.objects.create(name="Location Type 1")
+        location_type.content_types.add(ContentType.objects.get_for_model(RackGroup))
+
         cls.locations = (
             Location.objects.create(name="Location 1", location_type=location_type, status=cls.status),
             Location.objects.create(name="Location 2", location_type=location_type, status=cls.status),
@@ -548,8 +550,6 @@ class RackGroupTest(APIViewTestCases.APIViewTestCase, APIViewTestCases.TreeModel
             RackGroup.objects.create(location=cls.locations[1], name="Parent Rack Group 2"),
         )
 
-        location_type.content_types.add(ContentType.objects.get_for_model(RackGroup))
-
         RackGroup.objects.create(
             location=cls.locations[0],
             name="Rack Group 1",
@@ -643,7 +643,9 @@ class RackTest(APIViewTestCases.APIViewTestCase):
 
     @classmethod
     def setUpTestData(cls):
-        locations = Location.objects.all()[:2]
+        locations = Location.objects.filter(devices__isnull=False)[:2]
+        for location in locations:
+            location.location_type.content_types.add(ContentType.objects.get_for_model(RackGroup))
 
         rack_groups = (
             RackGroup.objects.create(location=locations[0], name="Rack Group 1"),
@@ -675,6 +677,20 @@ class RackTest(APIViewTestCases.APIViewTestCase):
             status=statuses[0],
         )
 
+        populated_rack = Rack.objects.create(
+            location=locations[0],
+            rack_group=rack_groups[0],
+            role=rack_roles[0],
+            name="Populated Rack",
+            status=statuses[0],
+        )
+        # Place a device in Rack 4
+        device = Device.objects.filter(location=populated_rack.location, rack=None).first()
+        device.rack = populated_rack
+        device.face = "front"
+        device.position = 10
+        device.save()
+
         cls.create_data = [
             {
                 "name": "Test Rack 4",
@@ -742,6 +758,44 @@ class RackTest(APIViewTestCases.APIViewTestCase):
         response = self.client.get(url, params, **self.header)
         self.assertHttpStatus(response, 200)
 
+    def test_filter_rack_elevation_is_occupied(self):
+        """
+        Test filtering the list of rack elevations by occupied status.
+        """
+        rack = Rack.objects.get(name="Populated Rack")
+        self.add_permissions("dcim.view_rack")
+        url = reverse("dcim-api:rack-elevation", kwargs={"pk": rack.pk})
+        # Get all units first
+        params = {"face": "front"}
+        response = self.client.get(url, params, **self.header)
+        all_units = response.data["results"]
+        # Assert the count is equal to the number of units in the rack
+        self.assertEqual(len(all_units), rack.u_height)
+
+        # Next get only unoccupied units
+        params = {"face": "front", "is_occupied": False}
+        response = self.client.get(url, params, **self.header)
+        unoccupied_units = response.data["results"]
+        # Assert the count is more than 0
+        self.assertGreater(len(unoccupied_units), 0)
+        # Assert the unoccupied count is less than the total number of units
+        self.assertLess(len(unoccupied_units), len(all_units))
+
+        # Next get only occupied units
+        params = {"face": "front", "is_occupied": True}
+        response = self.client.get(url, params, **self.header)
+        occupied_units = response.data["results"]
+        # Assert the count is more than 0
+        self.assertGreater(len(occupied_units), 0)
+        # Assert the occupied count is less than the total number of units
+        self.assertLess(len(occupied_units), len(all_units))
+
+        # Assert that the sum of unoccupied and occupied units is equal to the total number of units
+        self.assertEqual(len(unoccupied_units) + len(occupied_units), len(all_units))
+        # Assert that the lists are mutually exclusive
+        self.assertEqual(len([unit for unit in unoccupied_units if unit in occupied_units]), 0)
+        self.assertEqual(len([unit for unit in occupied_units if unit in unoccupied_units]), 0)
+
     def test_get_rack_elevation_svg(self):
         """
         GET a single rack elevation in SVG format.

nautobot/dcim/tests/test_models.py

@@ -65,7 +65,6 @@ from nautobot.dcim.models import (
 from nautobot.extras import context_managers
 from nautobot.extras.choices import CustomFieldTypeChoices
 from nautobot.extras.models import CustomField, Role, SecretsGroup, Status
-from nautobot.ipam.factory import VLANGroupFactory
 from nautobot.ipam.models import IPAddress, IPAddressToInterface, Namespace, Prefix, VLAN, VLANGroup
 from nautobot.tenancy.models import Tenant
 from nautobot.users.models import User
@@ -2351,7 +2350,6 @@ class InterfaceTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
             vid=100,
             location=location_2,
             status=vlan_status,
-            vlan_group=VLANGroupFactory.create(location=location_2),
         )
 
         cls.namespace = Namespace.objects.create(name="dcim_test_interface_ip_addresses")

nautobot/dcim/views.py

@@ -3148,7 +3148,7 @@ class DeviceBayPopulateView(generic.ObjectEditView):
                 f"Added {device_bay.installed_device} to {device_bay}.",
             )
 
-            return redirect("dcim:device", pk=device_bay.device.pk)
+            return redirect("dcim:device_devicebays", pk=device_bay.device.pk)
 
         return render(
             request,
@@ -3191,7 +3191,7 @@ class DeviceBayDepopulateView(generic.ObjectEditView):
                 f"Removed {removed_device} from {device_bay}.",
             )
 
-            return redirect("dcim:device", pk=device_bay.device.pk)
+            return redirect("dcim:device_devicebays", pk=device_bay.device.pk)
 
         return render(
             request,
@@ -4139,9 +4139,12 @@ class DeviceFamilyUIViewSet(NautobotUIViewSet):
             context["device_type_table"] = device_type_table
 
             total_devices = 0
+            device_type_count = 0
             for device_type in device_types:
                 total_devices += device_type.device_count
+                device_type_count += 1
             context["total_devices"] = total_devices
+            context["device_type_count"] = device_type_count
 
         return context
 

nautobot/extras/api/views.py

@@ -1,5 +1,6 @@
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
+from django.db.models import ProtectedError
 from django.forms import ValidationError as FormsValidationError
 from django.http import FileResponse, Http404
 from django.shortcuts import get_object_or_404
@@ -729,6 +730,14 @@ class JobViewSet(
 ):
     lookup_value_regex = r"[-0-9a-fA-F]+"
 
+    def perform_destroy(self, obj):
+        if obj.module_name.startswith("nautobot."):
+            raise ProtectedError(
+                f"Unable to delete Job {obj}. System Job cannot be deleted",
+                [],
+            )
+        super().perform_destroy(obj)
+
 
 @extend_schema_view(
     destroy=extend_schema(operation_id="extras_jobs_destroy_by_name"),

nautobot/extras/models/jobs.py

@@ -11,7 +11,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.core.validators import MinValueValidator
 from django.db import models, transaction
-from django.db.models import signals
+from django.db.models import ProtectedError, signals
 from django.utils import timezone
 from django.utils.functional import cached_property
 from django_celery_beat.clockedschedule import clocked
@@ -234,6 +234,14 @@ class Job(PrimaryModel):
     def __str__(self):
         return self.name
 
+    def delete(self):
+        if self.module_name.startswith("nautobot."):
+            raise ProtectedError(
+                f"Unable to delete Job {self}. System Job cannot be deleted",
+                [],
+            )
+        super().delete()
+
     @property
     def job_class(self):
         """

nautobot/extras/querysets.py

@@ -1,6 +1,6 @@
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
-from django.db.models import F, Model, OuterRef, Q, Subquery
+from django.db.models import F, Model, OuterRef, ProtectedError, Q, Subquery
 from django.db.models.functions import JSONObject
 
 from nautobot.core.models.query_functions import EmptyGroupByJSONBAgg
@@ -224,6 +224,15 @@ class JobQuerySet(RestrictedQuerySet):
     Extend the standard queryset with a get_for_class_path method.
     """
 
+    def delete(self):
+        for job in self:
+            if job.module_name.startswith("nautobot."):
+                raise ProtectedError(
+                    f"Unable to delete Job {job}. System Job cannot be deleted",
+                    [],
+                )
+        return super().delete()
+
     def get_for_class_path(self, class_path):
         try:
             module_name, job_class_name = class_path.rsplit(".", 1)

nautobot/extras/tables.py

@@ -1031,6 +1031,9 @@ class ObjectMetadataTable(BaseTable):
 class NoteTable(BaseTable):
     actions = ButtonsColumn(Note)
     created = tables.LinkColumn()
+    note = tables.Column(
+        attrs={"td": {"class": "rendered-markdown"}},
+    )
 
     class Meta(BaseTable.Meta):
         model = Note

nautobot/extras/tests/test_api.py

@@ -1388,6 +1388,42 @@ class JobTest(
         job_model = Job.objects.get_for_class_path(class_path)
         return reverse("extras-api:job-run", kwargs={"pk": job_model.pk})
 
+    def get_deletable_object(self):
+        """
+        Get an instance that can be deleted.
+        Exclude system jobs
+        """
+        # filter out the system jobs:
+        queryset = self._get_queryset().exclude(module_name__startswith="nautobot.")
+        instance = get_deletable_objects(self.model, queryset).first()
+        if instance is None:
+            self.fail("Couldn't find a single deletable object!")
+        return instance
+
+    def get_deletable_object_pks(self):
+        """
+        Get a list of PKs corresponding to jobs that can be safely bulk-deleted.
+        Exclude system jobs
+        """
+        queryset = self._get_queryset().exclude(module_name__startswith="nautobot.")
+        instances = get_deletable_objects(self.model, queryset).values_list("pk", flat=True)[:3]
+        if len(instances) < 3:
+            self.fail(f"Couldn't find 3 deletable objects, only found {len(instances)}!")
+        return instances
+
+    def test_delete_system_jobs_fail(self):
+        self.add_permissions("extras.delete_job")
+        instance = self._get_queryset().filter(module_name__startswith="nautobot.").first()
+        job_name = instance.name
+        url = self._get_detail_url(instance)
+        self.client.delete(url, **self.header)
+        # assert Job still exists
+        self.assertTrue(self._get_queryset().filter(name=job_name).exists())
+        self.user.is_superuser = True
+        self.client.delete(url, **self.header)
+        # assert Job still exists
+        self.assertTrue(self._get_queryset().filter(name=job_name).exists())
+
     def test_get_job_variables(self):
         """Test the job/<pk>/variables API endpoint."""
         self.add_permissions("extras.view_job")

nautobot/extras/tests/test_views.py

@@ -18,7 +18,7 @@ from nautobot.core.choices import ColorChoices
 from nautobot.core.models.fields import slugify_dashes_to_underscores
 from nautobot.core.templatetags.helpers import bettertitle
 from nautobot.core.testing import extract_form_failures, extract_page_body, ModelViewTestCase, TestCase, ViewTestCases
-from nautobot.core.testing.utils import disable_warnings, post_data
+from nautobot.core.testing.utils import disable_warnings, get_deletable_objects, post_data
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.dcim.models import (
     ConsolePort,
@@ -1840,6 +1840,9 @@ class ApprovalQueueTestCase(
             return reverse("extras:scheduledjob_approval_request_view", kwargs={"pk": instance.pk})
         raise ValueError("This override is only valid for list and view test cases")
 
+    def get_list_url(self):
+        return reverse("extras:scheduledjob_approval_queue_list")
+
     def setUp(self):
         super().setUp()
         self.job_model = Job.objects.get_for_class_path("dry_run.TestDryRun")
@@ -2363,6 +2366,78 @@ class JobTestCase(
             "clear_task_queues_override": False,
         }
 
+    def get_deletable_object(self):
+        """
+        Get an instance that can be deleted.
+        Exclude system jobs
+        """
+        # filter out the system jobs:
+        queryset = self._get_queryset().exclude(module_name__startswith="nautobot.")
+        return get_deletable_objects(self.model, queryset).first()
+
+    def get_deletable_object_pks(self):
+        """
+        Get a list of PKs corresponding to jobs that can be safely bulk-deleted.
+        Excluding system jobs
+        """
+        queryset = self._get_queryset().exclude(module_name__startswith="nautobot.")
+        return get_deletable_objects(self.model, queryset).values_list("pk", flat=True)[:3]
+
+    def test_delete_system_jobs_fail(self):
+        instance = self._get_queryset().filter(module_name__startswith="nautobot.").first()
+        job_name = instance.name
+        request = {
+            "path": self._get_url("delete", instance),
+            "data": post_data({"confirm": True}),
+        }
+
+        # Try delete with delete job permission
+        self.add_permissions("extras.delete_job")
+        response = self.client.post(**request, follow=True)
+        self.assertHttpStatus(response, 403)
+        response_body = extract_page_body(response.content.decode(response.charset))
+        self.assertIn(f"Unable to delete Job {instance}. System Job cannot be deleted", response_body)
+        # assert Job still exists
+        self.assertTrue(self._get_queryset().filter(name=job_name).exists())
+
+        # Try delete as a superuser
+        self.user.is_superuser = True
+        response = self.client.post(**request, follow=True)
+        self.assertHttpStatus(response, 403)
+        response_body = extract_page_body(response.content.decode(response.charset))
+        self.assertIn(f"Unable to delete Job {instance}. System Job cannot be deleted", response_body)
+        # 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.assertHttpStatus(response, 403)
+        self.assertEqual(self._get_queryset().count(), initial_count)
+        response_body = extract_page_body(response.content.decode(response.charset))
+        self.assertIn(
+            f"Unable to delete Job {system_job_queryset.first()}. System Job cannot be deleted", response_body
+        )
+
+        # Try bulk delete as a superuser
+        self.user.is_superuser = True
+        response = self.client.post(self._get_url("bulk_delete"), data, follow=True)
+        self.assertHttpStatus(response, 403)
+        self.assertEqual(self._get_queryset().count(), initial_count)
+        response_body = extract_page_body(response.content.decode(response.charset))
+        self.assertIn(
+            f"Unable to delete Job {system_job_queryset.first()}. System Job cannot be deleted", response_body
+        )
+
     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"]