nautobot 2.4.21__py3-none-any.whl → 3.0.0a3__py3-none-any.whl

nautobot/extras/tests/test_views.py

@@ -1,27 +1,30 @@
 from datetime import timedelta
-import json
 from unittest import mock
 import urllib.parse
 import uuid
 
 from django.contrib.auth import get_user_model
+from django.contrib.auth.models import Group
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.db.models import Q
-from django.test import override_settings
+from django.test import override_settings, tag
 from django.urls import reverse
 from django.utils import timezone
 from django.utils.html import escape, format_html
 
 from nautobot.circuits.models import Circuit
-from nautobot.core.celery import NautobotKombuJSONEncoder
 from nautobot.core.choices import ColorChoices
 from nautobot.core.models.fields import slugify_dashes_to_underscores
-from nautobot.core.models.utils import serialize_object_v2
 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.context import load_event_broker_override_settings
-from nautobot.core.testing.utils import disable_warnings, get_deletable_objects, post_data
+from nautobot.core.testing import (
+    extract_form_failures,
+    extract_page_body,
+    ModelViewTestCase,
+    TestCase,
+    ViewTestCases,
+)
+from nautobot.core.testing.utils import get_deletable_objects, post_data
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.dcim.models import (
     ConsolePort,
@@ -33,6 +36,7 @@ from nautobot.dcim.models import (
     Manufacturer,
 )
 from nautobot.extras.choices import (
+    ApprovalWorkflowStateChoices,
     CustomFieldTypeChoices,
     DynamicGroupTypeChoices,
     JobExecutionType,
@@ -46,6 +50,11 @@ from nautobot.extras.choices import (
 )
 from nautobot.extras.constants import HTTP_CONTENT_TYPE_JSON, JOB_OVERRIDABLE_FIELDS
 from nautobot.extras.models import (
+    ApprovalWorkflow,
+    ApprovalWorkflowDefinition,
+    ApprovalWorkflowStage,
+    ApprovalWorkflowStageDefinition,
+    ApprovalWorkflowStageResponse,
     ComputedField,
     ConfigContext,
     ConfigContextSchema,
@@ -88,7 +97,7 @@ 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_jobs import get_job_class_and_model
 from nautobot.extras.tests.test_relationships import RequiredRelationshipTestMixin
-from nautobot.extras.utils import RoleModelsQuery, TaggableClassesQuery
+from nautobot.extras.utils import get_pending_approval_workflow_stages, RoleModelsQuery, TaggableClassesQuery
 from nautobot.ipam.models import IPAddress, Prefix, VLAN, VLANGroup, VRF
 from nautobot.tenancy.models import Tenant
 from nautobot.users.models import ObjectPermission
@@ -97,6 +106,461 @@ from nautobot.users.models import ObjectPermission
 User = get_user_model()
 
 
+class ApprovalWorkflowDefinitionViewTestCase(
+    ViewTestCases.GetObjectViewTestCase,
+    ViewTestCases.GetObjectChangelogViewTestCase,
+    ViewTestCases.GetObjectNotesViewTestCase,
+    ViewTestCases.CreateObjectViewTestCase,
+    ViewTestCases.EditObjectViewTestCase,
+    ViewTestCases.DeleteObjectViewTestCase,
+    ViewTestCases.ListObjectsViewTestCase,
+    ViewTestCases.BulkDeleteObjectsViewTestCase,
+    # This is almost like ViewTestCases.PrimaryObjectViewTestCase, but without BulkEditObjectsViewTestCase,
+    # because ApprovalWorkflowDefinition doesn't have any fields that support bulk editing.
+    # Currently, `model_content_type` only accepts one content type: ScheduledJob.
+):
+    """Test the ApprovalWorkflowDefinition views."""
+
+    model = ApprovalWorkflowDefinition
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()
+        cls.scheduledjob_ct = ContentType.objects.get_for_model(ScheduledJob)
+        for i in range(5):
+            ApprovalWorkflowDefinition.objects.create(
+                name=f"Test Approval Workflow {i}",
+                model_content_type=cls.scheduledjob_ct,
+                weight=i,
+            )
+
+        cls.form_data = {
+            "name": "Test Approval Workflow Definition 5",
+            "model_content_type": cls.scheduledjob_ct.pk,
+            "model_constraints": '{"name": "Bulk Delete Objects"}',
+            "weight": 5,
+            # These are the "management_form" fields required by the dynamic CustomFieldChoice formsets.
+            "approval_workflow_stage_definitions-TOTAL_FORMS": "0",  # Set to 0 so validation succeeds until we need it
+            "approval_workflow_stage_definitions-INITIAL_FORMS": "1",
+            "approval_workflow_stage_definitions-MIN_NUM_FORMS": "0",
+            "approval_workflow_stage_definitions-MAX_NUM_FORMS": "1000",
+        }
+
+
+class ApprovalWorkflowStageDefinitionViewTestCase(ViewTestCases.PrimaryObjectViewTestCase):
+    """Test the ApprovalWorkflowStageDefinition views."""
+
+    model = ApprovalWorkflowStageDefinition
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()
+        cls.scheduledjob_ct = ContentType.objects.get_for_model(ScheduledJob)
+        cls.approval_workflow_definition = ApprovalWorkflowDefinition.objects.create(
+            name="Test Approval Workflow Definition 1",
+            model_content_type=cls.scheduledjob_ct,
+            weight=10,
+        )
+        cls.approver_group = Group.objects.create(name="Test Group 1")
+        cls.updated_approver_group = Group.objects.create(name="Test Group 2")
+        # Deletable objects
+        ApprovalWorkflowStageDefinition.objects.create(
+            approval_workflow_definition=cls.approval_workflow_definition,
+            sequence=100,
+            name="Test Approval Workflow 1 Stage 1 Definition",
+            min_approvers=2,
+            denial_message="Stage 1 Denial Message",
+            approver_group=cls.approver_group,
+        )
+        ApprovalWorkflowStageDefinition.objects.create(
+            approval_workflow_definition=cls.approval_workflow_definition,
+            sequence=200,
+            name="Test Approval Workflow 1 Stage 2 Definition",
+            min_approvers=3,
+            denial_message="Stage 2 Denial Message",
+            approver_group=cls.approver_group,
+        )
+        ApprovalWorkflowStageDefinition.objects.create(
+            approval_workflow_definition=cls.approval_workflow_definition,
+            sequence=300,
+            name="Test Approval Workflow 1 Stage 3 Definition",
+            min_approvers=4,
+            denial_message="Stage 3 Denial Message",
+            approver_group=cls.updated_approver_group,
+        )
+        ApprovalWorkflowStageDefinition.objects.create(
+            approval_workflow_definition=cls.approval_workflow_definition,
+            sequence=400,
+            name="Test Approval Workflow 1 Stage 4 Definition",
+            min_approvers=4,
+            denial_message="Stage 4 Denial Message",
+            approver_group=cls.updated_approver_group,
+        )
+        ApprovalWorkflowStageDefinition.objects.create(
+            approval_workflow_definition=cls.approval_workflow_definition,
+            sequence=500,
+            name="Test Approval Workflow 1 Stage 5 Definition",
+            min_approvers=4,
+            denial_message="Stage 5 Denial Message",
+            approver_group=cls.updated_approver_group,
+        )
+
+        cls.form_data = {
+            "approval_workflow_definition": cls.approval_workflow_definition.pk,
+            "sequence": 600,
+            "name": "Approval Workflow Stage 1 Definition",
+            "min_approvers": 2,
+            "denial_message": "Stage 1 is denied",
+            "approver_group": cls.approver_group.pk,
+        }
+
+        cls.update_data = {
+            "approval_workflow_definition": cls.approval_workflow_definition.pk,
+            "sequence": 700,
+            "name": "Updated approval workflow stage 1",
+            "min_approvers": 3,
+            "denial_message": "updated message",
+            "approver_group": cls.updated_approver_group.pk,
+        }
+
+        cls.bulk_edit_data = {
+            "sequence": 800,
+            "min_approvers": 5,
+            "denial_message": "updated denial message",
+        }
+
+
+class ApprovalWorkflowViewTestCase(
+    ViewTestCases.GetObjectViewTestCase,
+    ViewTestCases.GetObjectChangelogViewTestCase,
+    ViewTestCases.GetObjectNotesViewTestCase,
+    ViewTestCases.DeleteObjectViewTestCase,
+    ViewTestCases.ListObjectsViewTestCase,
+    ViewTestCases.BulkDeleteObjectsViewTestCase,
+):
+    """Test the ApprovalWorkflow views."""
+
+    model = ApprovalWorkflow
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()
+        cls.scheduledjob_ct = ContentType.objects.get_for_model(ScheduledJob)
+        job_model = Job.objects.get_for_class_path("pass_job.TestPassJob")
+        user = User.objects.first()
+        cls.scheduled_jobs = [
+            ScheduledJob.objects.create(
+                name=f"TessPassJob Scheduled Job {i}",
+                task="pass_job.TestPassJob",
+                job_model=job_model,
+                interval=JobExecutionType.TYPE_IMMEDIATELY,
+                user=user,
+                start_time=timezone.now(),
+            )
+            for i in range(7)
+        ]
+        approval_workflow_definitions = [
+            ApprovalWorkflowDefinition.objects.create(
+                name=f"Test Approval Workflow {i}", model_content_type=cls.scheduledjob_ct, weight=i
+            )
+            for i in range(5)
+        ]
+        cls.approval_workflows = [
+            ApprovalWorkflow.objects.create(
+                approval_workflow_definition=approval_workflow_definitions[i],
+                object_under_review_content_type=cls.scheduledjob_ct,
+                object_under_review_object_id=cls.scheduled_jobs[i].pk,
+                current_state=ApprovalWorkflowStateChoices.PENDING,
+            )
+            for i in range(5)
+        ]
+
+        cls.form_data = {
+            "approval_workflow_definition": approval_workflow_definitions[3].pk,
+            "object_under_review_content_type": cls.scheduledjob_ct.pk,
+            "object_under_review_object_id": cls.scheduled_jobs[5].pk,
+            "current_state": ApprovalWorkflowStateChoices.PENDING,
+        }
+
+        cls.update_data = {
+            "approval_workflow_definition": approval_workflow_definitions[3].pk,
+            "object_under_review_content_type": cls.scheduledjob_ct.pk,
+            "object_under_review_object_id": cls.scheduled_jobs[6].pk,
+            "current_state": ApprovalWorkflowStateChoices.APPROVED,
+        }
+
+        cls.bulk_edit_data = {
+            "current_state": ApprovalWorkflowStateChoices.DENIED,
+        }
+
+
+class ApprovalWorkflowStageViewTestCase(
+    ViewTestCases.GetObjectViewTestCase,
+    ViewTestCases.GetObjectChangelogViewTestCase,
+    ViewTestCases.GetObjectNotesViewTestCase,
+    ViewTestCases.DeleteObjectViewTestCase,
+    ViewTestCases.ListObjectsViewTestCase,
+    ViewTestCases.BulkDeleteObjectsViewTestCase,
+):
+    """Test the ApprovalWorkflowStage views."""
+
+    model = ApprovalWorkflowStage
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()
+        cls.scheduledjob_ct = ContentType.objects.get_for_model(ScheduledJob)
+        job_model = Job.objects.get_for_class_path("pass_job.TestPassJob")
+        user = User.objects.first()
+        cls.scheduled_jobs = [
+            ScheduledJob.objects.create(
+                name=f"TessPassJob Scheduled Job {i}",
+                task="pass_job.TestPassJob",
+                job_model=job_model,
+                interval=JobExecutionType.TYPE_IMMEDIATELY,
+                user=user,
+                start_time=timezone.now(),
+            )
+            for i in range(6)
+        ]
+        cls.approver_groups = [Group.objects.create(name=f"Test Group {i}") for i in range(3)]
+        cls.approval_workflow_definitions = [
+            ApprovalWorkflowDefinition.objects.create(
+                name=f"Test Approval Workflow {i}",
+                model_content_type=cls.scheduledjob_ct,
+                weight=i,
+            )
+            for i in range(5)
+        ]
+        cls.approval_workflow_stage_definitions = []
+        for approval_workflow_definition in cls.approval_workflow_definitions:
+            for i in range(3):
+                cls.approval_workflow_stage_definitions.append(
+                    ApprovalWorkflowStageDefinition.objects.create(
+                        approval_workflow_definition=approval_workflow_definition,
+                        sequence=i * 100,
+                        name=f"Test Approval Workflow Stage {i} Definition",
+                        min_approvers=i + 1,
+                        denial_message=f"Stage {i} Denial Message",
+                        approver_group=cls.approver_groups[i],
+                    )
+                )
+        cls.approval_workflows = [
+            ApprovalWorkflow.objects.create(
+                approval_workflow_definition=cls.approval_workflow_definitions[i],
+                object_under_review_content_type=cls.scheduledjob_ct,
+                object_under_review_object_id=cls.scheduled_jobs[i].pk,
+                current_state=ApprovalWorkflowStateChoices.PENDING,
+            )
+            for i in range(5)
+        ]
+        for i, approval_workflow in enumerate(cls.approval_workflows[:2]):
+            for j in range(3):
+                ApprovalWorkflowStage.objects.create(
+                    approval_workflow=approval_workflow,
+                    approval_workflow_stage_definition=cls.approval_workflow_stage_definitions[i * 3 + j],
+                    state=ApprovalWorkflowStateChoices.PENDING,
+                )
+
+        cls.form_data = {
+            "approval_workflow": cls.approval_workflows[2].pk,
+            "approval_workflow_stage_definition": cls.approval_workflow_stage_definitions[6].pk,
+            "state": ApprovalWorkflowStateChoices.PENDING,
+        }
+
+        cls.bulk_edit_data = {
+            "state": ApprovalWorkflowStateChoices.DENIED,
+        }
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_approver_dashboard(self):
+        """Test the approval dashboard endpoint."""
+        self.client.force_login(self.user)
+        self.add_permissions("extras.view_approvalworkflowstage")
+
+        # Try GET with model-level permission
+        url = reverse("extras:approver_dashboard")
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 200)
+        self.assertBodyContains(response, "My Approvals")  # Assert the dashboard title is present
+        stages = get_pending_approval_workflow_stages(self.user, ApprovalWorkflowStage.objects.all())
+        for stage in stages:
+            self.assertBodyContains(response, str(stage.pk))  # Assert the stage uuid is present in the response
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_approvee_dashboard(self):
+        """Test the approval dashboard endpoint."""
+        self.client.force_login(self.user)
+        self.add_permissions("extras.view_approvalworkflowstage")
+
+        # Try GET with model-level permission
+        url = reverse("extras:approvee_dashboard")
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 200)
+        self.assertBodyContains(response, "My Requests")  # Assert the dashboard title is present
+        stages = ApprovalWorkflow.objects.filter(user=self.user)
+        for stage in stages:
+            self.assertBodyContains(response, str(stage.pk))  # Assert the stage uuid is present in the response
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_approve_endpoint(self):
+        """Test the approve endpoint."""
+        approval_workflow_stage = ApprovalWorkflowStage.objects.first()
+        self.client.force_login(self.user)
+        self.add_permissions("extras.change_approvalworkflowstage", "extras.view_approvalworkflowstage")
+
+        # Try GET with model-level permission
+        url = reverse("extras:approvalworkflowstage_approve", args=[approval_workflow_stage.pk])
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 200)
+        self.assertBodyContains(response, '<div class="card border-success">')  # Assert the success panel is present
+
+        # Try POST with model-level permission
+        request = {
+            "path": url,
+            "data": post_data({"comments": "Approved!"}),
+        }
+        response = self.client.post(**request, follow=True)
+        self.assertHttpStatus(response, 200)
+        approval_workflow_stage.refresh_from_db()
+        # New response should be created
+        new_response = ApprovalWorkflowStageResponse.objects.get(
+            approval_workflow_stage=approval_workflow_stage, user=self.user
+        )
+        self.assertEqual(new_response.state, ApprovalWorkflowStateChoices.APPROVED)
+        self.assertEqual(new_response.comments, "Approved!")
+        self.assertBodyContains(
+            response, f"You approved {approval_workflow_stage}."
+        )  # Assert the approval message is present
+
+        # Check approval work flow stage detail view
+        url = reverse("extras:approvalworkflowstage", args=[approval_workflow_stage.pk])
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 200)
+        self.assertBodyContains(response, "Approval Date")  # Assert the approval date is present
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_deny_endpoint(self):
+        """Test the deny endpoint."""
+        approval_workflow_stage = ApprovalWorkflowStage.objects.first()
+        self.add_permissions("extras.change_approvalworkflowstage", "extras.view_approvalworkflowstage")
+
+        # Try GET with model-level permission
+        url = reverse("extras:approvalworkflowstage_deny", args=[approval_workflow_stage.pk])
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 200)
+        self.assertBodyContains(response, '<div class="card border-danger">')  # Assert the danger panel is present
+
+        # Try POST with model-level permission
+        request = {
+            "path": url,
+            "data": post_data({"comments": "Denied!"}),
+        }
+        response = self.client.post(**request, follow=True)
+        self.assertHttpStatus(response, 200)
+        approval_workflow_stage.refresh_from_db()
+        # New response should be created
+        new_response = ApprovalWorkflowStageResponse.objects.get(
+            approval_workflow_stage=approval_workflow_stage, user=self.user
+        )
+        self.assertEqual(new_response.state, ApprovalWorkflowStateChoices.DENIED)
+        self.assertEqual(new_response.comments, "Denied!")
+        self.assertBodyContains(
+            response, f"You denied {approval_workflow_stage}."
+        )  # Assert the denial message is present
+
+        # Check approval work flow stage detail view
+        url = reverse("extras:approvalworkflowstage", args=[approval_workflow_stage.pk])
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 200)
+        self.assertBodyContains(response, "Denial Date")  # Assert the denial date is present
+
+
+class ApprovalWorkflowStageResponseViewTestCase(
+    ViewTestCases.DeleteObjectViewTestCase,
+    ViewTestCases.BulkDeleteObjectsViewTestCase,
+):
+    """Test the ApprovalWorkflowStageResponse views."""
+
+    model = ApprovalWorkflowStageResponse
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data."""
+        super().setUpTestData()
+        cls.scheduledjob_ct = ContentType.objects.get_for_model(ScheduledJob)
+        cls.approver_groups = [Group.objects.create(name=f"Test Group {i}") for i in range(3)]
+        cls.users = User.objects.all()
+        for user in cls.users:
+            for group in cls.approver_groups:
+                user.groups.add(group)
+
+        job_model = Job.objects.get_for_class_path("pass_job.TestPassJob")
+        cls.scheduled_jobs = [
+            ScheduledJob.objects.create(
+                name=f"TessPassJob Scheduled Job {i}",
+                task="pass_job.TestPassJob",
+                job_model=job_model,
+                interval=JobExecutionType.TYPE_IMMEDIATELY,
+                user=cls.users[0],
+                start_time=timezone.now(),
+            )
+            for i in range(6)
+        ]
+
+        cls.approval_workflow_definitions = [
+            ApprovalWorkflowDefinition.objects.create(
+                name=f"Test Approval Workflow {i} Definition",
+                model_content_type=cls.scheduledjob_ct,
+                weight=i,
+            )
+            for i in range(5)
+        ]
+        cls.approval_workflow_stage_definitions = []
+        for approval_workflow_definition in cls.approval_workflow_definitions:
+            for i in range(3):
+                cls.approval_workflow_stage_definitions.append(
+                    ApprovalWorkflowStageDefinition.objects.create(
+                        approval_workflow_definition=approval_workflow_definition,
+                        sequence=i * 100,
+                        name=f"Test Approval Workflow Stage {i} Definition",
+                        min_approvers=i + 1,
+                        denial_message=f"Stage {i} Denial Message",
+                        approver_group=cls.approver_groups[i],
+                    )
+                )
+        cls.approval_workflows = [
+            ApprovalWorkflow.objects.create(
+                approval_workflow_definition=cls.approval_workflow_definitions[i],
+                object_under_review_content_type=cls.scheduledjob_ct,
+                object_under_review_object_id=cls.scheduled_jobs[i].pk,
+                current_state=ApprovalWorkflowStateChoices.PENDING,
+            )
+            for i in range(5)
+        ]
+        cls.approval_workflow_stages = []
+        for i, approval_workflow in enumerate(cls.approval_workflows):
+            for j in range(3):
+                approval_workflow_stage = ApprovalWorkflowStage.objects.create(
+                    approval_workflow=approval_workflow,
+                    approval_workflow_stage_definition=cls.approval_workflow_stage_definitions[i * 3 + j],
+                    state=ApprovalWorkflowStateChoices.PENDING,
+                )
+                cls.approval_workflow_stages.append(approval_workflow_stage)
+                if i < 2:
+                    # Create responses for the first two approval workflow instances
+                    ApprovalWorkflowStageResponse.objects.create(
+                        approval_workflow_stage=approval_workflow_stage,
+                        user=cls.users[i],
+                        comments=f"Test comment {i * 3 + j}",
+                        state=ApprovalWorkflowStateChoices.PENDING,
+                    )
+
+
 class ComputedFieldTestCase(
     ViewTestCases.BulkDeleteObjectsViewTestCase,
     ViewTestCases.CreateObjectViewTestCase,
@@ -1339,13 +1803,13 @@ class GitRepositoryTestCase(
     model = GitRepository
     slugify_function = staticmethod(slugify_dashes_to_underscores)
     expected_edit_form_buttons = [
-        '<button type="submit" name="_dryrun_update" class="btn btn-warning">Update & Dry Run</button>',
-        '<button type="submit" name="_update" class="btn btn-primary">Update & Sync</button>',
+        '<button type="submit" name="_dryrun_update" class="btn btn-warning"><span aria-hidden="true" class="mdi mdi-check me-4"></span><!---->Update & Dry Run</button>',
+        '<button type="submit" name="_update" class="btn btn-primary"><span aria-hidden="true" class="mdi mdi-check me-4"></span><!---->Update & Sync</button>',
     ]
     expected_create_form_buttons = [
-        '<button type="submit" name="_dryrun_create" class="btn btn-info">Create & Dry Run</button>',
-        '<button type="submit" name="_create" class="btn btn-primary">Create & Sync</button>',
-        '<button type="submit" name="_addanother" class="btn btn-primary">Create and Add Another</button>',
+        '<button type="submit" name="_dryrun_create" class="btn btn-info"><span aria-hidden="true" class="mdi mdi-check me-4"></span><!---->Create & Dry Run</button>',
+        '<button type="submit" name="_create" class="btn btn-primary"><span aria-hidden="true" class="mdi mdi-check me-4"></span><!---->Create & Sync</button>',
+        '<button type="submit" name="_addanother" class="btn btn-primary"><span aria-hidden="true" class="mdi mdi-check me-4"></span><!---->Create and Add Another</button>',
     ]
 
     @classmethod
@@ -1753,7 +2217,11 @@ class SavedViewTest(ModelViewTestCase):
         )
         response = self.client.get(reverse(view_name), follow=True)
         # Assert that Location List View got redirected to Saved View set as global default
-        self.assertBodyContains(response, "<strong>Global Location Default View</strong>", html=True)
+        self.assertBodyContains(
+            response,
+            '<span aria-hidden="true" class="mdi mdi-check"></span>Global Location Default View<span class="mdi mdi-earth ms-auto" aria-hidden="true" data-bs-toggle="tooltip" data-bs-title="Global default" data-bs-fallback-placements="[&quot;top&quot;]"></span>',
+            html=True,
+        )
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_user_default(self):
@@ -1767,7 +2235,11 @@ class SavedViewTest(ModelViewTestCase):
         UserSavedViewAssociation.objects.create(user=self.user, saved_view=sv, view_name=sv.view)
         response = self.client.get(reverse(view_name), follow=True)
         # Assert that Location List View got redirected to Saved View set as user default
-        self.assertBodyContains(response, "<strong>User Location Default View</strong>", html=True)
+        self.assertBodyContains(
+            response,
+            '<span aria-hidden="true" class="mdi mdi-check"></span>User Location Default View<span class="mdi mdi-star ms-auto" aria-hidden="true" data-bs-toggle="tooltip" data-bs-title="Your default" data-bs-fallback-placements="[&quot;top&quot;]"></span>',
+            html=True,
+        )
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_user_default_precedes_global_default(self):
@@ -1786,7 +2258,11 @@ class SavedViewTest(ModelViewTestCase):
         UserSavedViewAssociation.objects.create(user=self.user, saved_view=sv, view_name=sv.view)
         response = self.client.get(reverse(view_name), follow=True)
         # Assert that Location List View got redirected to Saved View set as user default
-        self.assertBodyContains(response, "<strong>User Location Default View</strong>", html=True)
+        self.assertBodyContains(
+            response,
+            '<span aria-hidden="true" class="mdi mdi-check"></span>User Location Default View<span class="mdi mdi-star ms-auto" aria-hidden="true" data-bs-toggle="tooltip" data-bs-title="Your default" data-bs-fallback-placements="[&quot;top&quot;]"></span>',
+            html=True,
+        )
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_filtered_view_precedes_global_default(self):
@@ -1807,7 +2283,7 @@ class SavedViewTest(ModelViewTestCase):
         # Assert that the user is not redirected to the global default view
         # But instead redirected to the filtered view
         self.assertNotIn(
-            "<strong>Global Location Default View</strong>",
+            '<span aria-hidden="true" class="mdi mdi-check"></span>Global Location Default View<span class="mdi mdi-earth ms-auto" aria-hidden="true" data-bs-toggle="tooltip" data-bs-title="Global default" data-bs-fallback-placements="[&quot;top&quot;]"></span>',
             extract_page_body(response.content.decode(response.charset)),
         )
 
@@ -1836,7 +2312,8 @@ class SavedViewTest(ModelViewTestCase):
         # Assert that the user is not redirected to the user default view
         # But instead redirected to the filtered view
         self.assertNotIn(
-            "<strong>User Location Default View</strong>", extract_page_body(response.content.decode(response.charset))
+            '<span aria-hidden="true" class="mdi mdi-check"></span>User Location Default View<span class="mdi mdi-star ms-auto" aria-hidden="true" data-bs-toggle="tooltip" data-bs-title="Your default" data-bs-fallback-placements="[&quot;top&quot;]"></span>',
+            extract_page_body(response.content.decode(response.charset)),
         )
         # Floor type locations (Floor-<number>) should not be visible in the response
         self.assertNotIn(
@@ -1869,6 +2346,7 @@ class SavedViewTest(ModelViewTestCase):
         self.assertIn(str(sv_shared.pk), response_body, msg=response_body)
         self.assertNotIn(str(sv_not_shared.pk), response_body, msg=response_body)
 
+    @tag("example_app")
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_create_saved_views_contain_boolean_filter_params(self):
         """
@@ -1899,7 +2377,9 @@ class SavedViewTest(ModelViewTestCase):
             self.assertHttpStatus(response, 200)
             response_body = extract_page_body(response.content.decode(response.charset))
             self.assertIn(str(instance.pk), response_body, msg=response_body)
-            self.assertBodyContains(response, f"<strong>{sv_name}</strong>", html=True)
+            self.assertBodyContains(
+                response, f'<span aria-hidden="true" class="mdi mdi-check"></span>{sv_name}', html=True
+            )
             # This is the description
             self.assertBodyContains(response, "I should not show in the UI!", html=True)
 
@@ -1929,7 +2409,9 @@ class SavedViewTest(ModelViewTestCase):
             self.assertHttpStatus(response, 200)
             response_body = extract_page_body(response.content.decode(response.charset))
             self.assertIn(str(instance.pk), response_body, msg=response_body)
-            self.assertBodyContains(response, f"<strong>{sv_name}</strong>", html=True)
+            self.assertBodyContains(
+                response, f'<span aria-hidden="true" class="mdi mdi-check"></span>{sv_name}', html=True
+            )
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_update_saved_view_contain_boolean_filter_params(self):
@@ -1956,7 +2438,11 @@ class SavedViewTest(ModelViewTestCase):
             self.assertHttpStatus(response, 200)
             response_body = extract_page_body(response.content.decode(response.charset))
             self.assertNotIn("Example hidden job", response_body, msg=response_body)
-            self.assertBodyContains(response, f"<strong>{sv_name}</strong>", html=True)
+            self.assertBodyContains(
+                response,
+                f'<span aria-hidden="true" class="mdi mdi-check"></span>{sv_name}<span class="mdi mdi-account-group ms-auto" aria-hidden="true" data-bs-toggle="tooltip" data-bs-title="Shared" data-bs-fallback-placements="[&quot;top&quot;]"></span>',
+                html=True,
+            )
 
         with self.subTest("Update device Saved View with boolean filter parameters"):
             view_name = "dcim:device_list"
@@ -1980,7 +2466,11 @@ class SavedViewTest(ModelViewTestCase):
             # Assert that Job List View rendered with the boolean filter parameter without error
             self.assertHttpStatus(response, 200)
             response_body = extract_page_body(response.content.decode(response.charset))
-            self.assertBodyContains(response, f"<strong>{sv_name}</strong>", html=True)
+            self.assertBodyContains(
+                response,
+                f'<span aria-hidden="true" class="mdi mdi-check"></span>{sv_name}<span class="mdi mdi-account-group ms-auto" aria-hidden="true" data-bs-toggle="tooltip" data-bs-title="Shared" data-bs-fallback-placements="[&quot;top&quot;]"></span>',
+                html=True,
+            )
 
 
 # Not a full-fledged PrimaryObjectViewTestCase as there's no BulkEditView for Secrets
@@ -2282,6 +2772,42 @@ class ScheduledJobTestCase(
         self.assertHttpStatus(response, 200)
         self.assertNotIn("test4", extract_page_body(response.content.decode(response.charset)))
 
+    def test_approved_required_jobs_are_listed_only_when_approved(self):
+        self.add_permissions("extras.view_scheduledjob")
+
+        # this should not appear, since it's not approved
+        ScheduledJob.objects.create(
+            enabled=True,
+            approval_required=True,
+            decision_date=None,
+            name="test4",
+            task="pass_job.TestPassJob",
+            interval=JobExecutionType.TYPE_IMMEDIATELY,
+            user=self.user,
+            start_time=timezone.now(),
+        )
+        ScheduledJob.objects.create(
+            enabled=True,
+            approval_required=False,
+            name="test5",
+            task="pass_job.TestPassJob",
+            interval=JobExecutionType.TYPE_IMMEDIATELY,
+            user=self.user,
+            start_time=timezone.now(),
+        )
+        response = self.client.get(self._get_url("list"))
+        self.assertHttpStatus(response, 200)
+        self.assertNotIn("test4", extract_page_body(response.content.decode(response.charset)))
+        self.assertIn("test5", extract_page_body(response.content.decode(response.charset)))
+
+        scheduled_job = ScheduledJob.objects.get(name="test4")
+        scheduled_job.decision_date = timezone.now()
+        scheduled_job.save()
+
+        response = self.client.get(self._get_url("list"))
+        self.assertHttpStatus(response, 200)
+        self.assertIn("test4", extract_page_body(response.content.decode(response.charset)))
+
     def test_non_valid_crontab_syntax(self):
         self.add_permissions("extras.view_scheduledjob")
 
@@ -2332,442 +2858,33 @@ class ScheduledJobTestCase(
         self.assertIn("test11", extract_page_body(response.content.decode(response.charset)))
 
 
-class ApprovalQueueTestCase(
-    # It would be nice to use ViewTestCases.GetObjectViewTestCase as well,
-    # but we can't directly use it as it uses instance.get_absolute_url() rather than self._get_url("view", instance)
-    ViewTestCases.ListObjectsViewTestCase,
-):
-    model = ScheduledJob
-    # Many interactions with a ScheduledJob also require permissions to view the associated Job
-    user_permissions = ("extras.view_job",)
+class JobQueueTestCase(ViewTestCases.PrimaryObjectViewTestCase):
+    model = JobQueue
 
-    def _get_url(self, action, instance=None):
-        if action == "list":
-            return reverse("extras:scheduledjob_approval_queue_list")
-        if action == "view" and instance is not None:
-            return reverse("extras:scheduledjob_approval_request_view", kwargs={"pk": instance.pk})
-        raise ValueError("This override is only valid for list and view test cases")
+    @classmethod
+    def setUpTestData(cls):
+        cls.form_data = {
+            "name": "Test Job Queue",
+            "queue_type": JobQueueTypeChoices.TYPE_CELERY,
+            "description": "This is a very detailed description",
+            "tenant": Tenant.objects.first().pk,
+            "tags": [t.pk for t in Tag.objects.get_for_model(JobQueue)],
+        }
+        cls.bulk_edit_data = {
+            "queue_type": JobQueueTypeChoices.TYPE_KUBERNETES,
+            "description": "This is a very detailed new description",
+            "tenant": Tenant.objects.last().pk,
+            # TODO add tests for add_tags/remove_tags fields in TagsBulkEditFormMixin
+        }
 
-    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")
-        self.job_model_2 = Job.objects.get_for_class_path("fail.TestFailJob")
-
-        ScheduledJob.objects.create(
-            name="test1",
-            task="dry_run.TestDryRun",
-            job_model=self.job_model,
-            interval=JobExecutionType.TYPE_IMMEDIATELY,
-            user=self.user,
-            approval_required=True,
-            start_time=timezone.now(),
-        )
-        ScheduledJob.objects.create(
-            name="test2",
-            task="fail.TestFailJob",
-            job_model=self.job_model_2,
-            interval=JobExecutionType.TYPE_IMMEDIATELY,
-            user=self.user,
-            approval_required=True,
-            start_time=timezone.now(),
-        )
-
-    def test_only_approvable_is_listed(self):
-        self.add_permissions("extras.view_scheduledjob")
-
-        ScheduledJob.objects.create(
-            name="test4",
-            task="pass_job.TestPassJob",
-            job_model=self.job_model,
-            interval=JobExecutionType.TYPE_IMMEDIATELY,
-            user=self.user,
-            approval_required=False,
-            start_time=timezone.now(),
-        )
-
-        response = self.client.get(self._get_url("list"))
-        self.assertHttpStatus(response, 200)
-        self.assertNotIn("test4", extract_page_body(response.content.decode(response.charset)))
-
-    #
-    # Reimplementations of ViewTestCases.GetObjectViewTestCase test functions.
-    # Needed because those use instance.get_absolute_url() instead of self._get_url("view", instance)...
-    #
-
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
-    def test_get_object_anonymous(self):
-        self.client.logout()
-        response = self.client.get(self._get_url("view", self._get_queryset().first()))
-        self.assertHttpStatus(response, 200)
-
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
-    def test_get_object_without_permission(self):
-        instance = self._get_queryset().first()
-
-        with disable_warnings("django.request"):
-            self.assertHttpStatus(self.client.get(self._get_url("view", instance)), 403)
-
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
-    def test_get_object_with_permission(self):
-        instance = self._get_queryset().first()
-
-        # Add model-level permission
-        obj_perm = ObjectPermission(name="Test permission", actions=["view"])
-        obj_perm.save()
-        obj_perm.users.add(self.user)
-        obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
-
-        # Try GET with model-level permission
-        response = self.client.get(self._get_url("view", instance))
-        # The object's display name or string representation should appear in the response
-        self.assertBodyContains(response, getattr(instance, "display", str(instance)))
-
-        # skip GetObjectViewTestCase checks for Relationships and Custom Fields since this isn't actually a detail view
-
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
-    def test_get_object_with_constrained_permission(self):
-        instance1, instance2 = self._get_queryset().all()[:2]
-
-        # Add object-level permission
-        obj_perm = ObjectPermission(
-            name="Test permission",
-            constraints={"pk": instance1.pk},
-            # To get a different rendering flow than the "test_get_object_with_permission" test above,
-            # enable additional permissions for this object so that interaction buttons are rendered.
-            actions=["view", "add", "change", "delete"],
-        )
-        obj_perm.save()
-        obj_perm.users.add(self.user)
-        obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
-
-        # Try GET to permitted object
-        self.assertHttpStatus(self.client.get(self._get_url("view", instance1)), 200)
-
-        # Try GET to non-permitted object
-        self.assertHttpStatus(self.client.get(self._get_url("view", instance2)), 404)
-
-    #
-    # Additional test cases specific to the job approval view
-    #
-
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
-    def test_post_anonymous(self):
-        """Anonymous users may not take any action with regard to job approval requests."""
-        self.client.logout()
-        response = self.client.post(self._get_url("view", self._get_queryset().first()))
-        self.assertBodyContains(response, "You do not have permission to run jobs")
-        # No job was submitted
-        self.assertFalse(JobResult.objects.filter(name=self.job_model.name).exists())
-
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
-    def test_post_dry_run_not_runnable(self):
-        """A non-enabled job cannot be dry-run."""
-        self.add_permissions("extras.view_scheduledjob")
-        instance = self._get_queryset().first()
-        data = {"_dry_run": True}
-
-        response = self.client.post(self._get_url("view", instance), data)
-        self.assertBodyContains(response, "This job cannot be run at this time")
-        # No job was submitted
-        self.assertFalse(JobResult.objects.filter(name=instance.job_model.name).exists())
-
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
-    def test_post_dry_run_needs_job_run_permission(self):
-        """A user without run_job permission cannot dry-run a job."""
-        self.add_permissions("extras.view_scheduledjob")
-        instance = self._get_queryset().first()
-        instance.job_model.enabled = True
-        instance.job_model.save()
-        data = {"_dry_run": True}
-
-        response = self.client.post(self._get_url("view", instance), data)
-        self.assertBodyContains(response, "You do not have permission to run this job")
-        # No job was submitted
-        self.assertFalse(JobResult.objects.filter(name=instance.job_model.name).exists())
-
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
-    def test_post_dry_run_needs_specific_job_run_permission(self):
-        """A user without run_job permission FOR THAT SPECIFIC JOB cannot dry-run a job."""
-        self.add_permissions("extras.view_scheduledjob")
-        instance1, instance2 = self._get_queryset().all()[:2]
-        data = {"_dry_run": True}
-        obj_perm = ObjectPermission(name="Test permission", constraints={"pk": instance1.job_model.pk}, actions=["run"])
-        obj_perm.save()
-        obj_perm.users.add(self.user)
-        obj_perm.object_types.add(ContentType.objects.get_for_model(Job))
-        instance1.job_model.enabled = True
-        instance1.job_model.save()
-        instance2.job_model.enabled = True
-        instance2.job_model.save()
-
-        response = self.client.post(self._get_url("view", instance2), data)
-        self.assertBodyContains(response, "You do not have permission to run this job")
-        # No job was submitted
-        job_names = [instance1.job_model.name, instance2.job_model.name]
-        self.assertFalse(JobResult.objects.filter(name__in=job_names).exists())
-
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
-    @mock.patch("nautobot.extras.views.get_worker_count", return_value=1)
-    def test_post_dry_run_not_supported(self, _):
-        """Request a dry run on a job that doesn't support dryrun."""
-        self.add_permissions("extras.view_scheduledjob")
-        instance = ScheduledJob.objects.filter(name="test2").first()
-        instance.job_model.enabled = True
-        instance.job_model.save()
-        obj_perm = ObjectPermission(name="Test permission", constraints={"pk": instance.job_model.pk}, actions=["run"])
-        obj_perm.save()
-        obj_perm.users.add(self.user)
-        obj_perm.object_types.add(ContentType.objects.get_for_model(Job))
-        data = {"_dry_run": True}
-
-        response = self.client.post(self._get_url("view", instance), data)
-        # Job was not submitted
-        self.assertFalse(JobResult.objects.filter(name=instance.job_model.class_path).exists())
-        self.assertContains(response, "This job does not support dryrun")
-
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
-    @mock.patch("nautobot.extras.views.get_worker_count", return_value=1)
-    @mock.patch("nautobot.extras.models.jobs.JobResult.enqueue_job")
-    def test_post_dry_run_success(self, mock_enqueue_job, _):
-        """Successfully request a dry run based on object-based run_job permissions."""
-        self.add_permissions("extras.view_scheduledjob")
-        instance = ScheduledJob.objects.filter(name="test1").first()
-        instance.job_model.enabled = True
-        instance.job_model.save()
-        obj_perm = ObjectPermission(name="Test permission", constraints={"pk": instance.job_model.pk}, actions=["run"])
-        obj_perm.save()
-        obj_perm.users.add(self.user)
-        obj_perm.object_types.add(ContentType.objects.get_for_model(Job))
-        data = {"_dry_run": True}
-
-        mock_enqueue_job.side_effect = lambda job_model, *args, **kwargs: JobResult.objects.create(name=job_model.name)
-
-        response = self.client.post(self._get_url("view", instance), data)
-        # Job was submitted
-        mock_enqueue_job.assert_called_once()
-        job_result = JobResult.objects.get(name=instance.job_model.name)
-        self.assertRedirects(response, reverse("extras:jobresult", kwargs={"pk": job_result.pk}))
-
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
-    def test_post_deny_different_user_lacking_permissions(self):
-        """A user needs both delete_scheduledjob and approve_job permissions to deny a job request."""
-        user1 = User.objects.create_user(username="testuser1")
-        user2 = User.objects.create_user(username="testuser2")
-
-        # Give both users view_scheduledjob permission
-        obj_perm = ObjectPermission(name="View", actions=["view"])
-        obj_perm.save()
-        obj_perm.users.add(user1, user2)
-        obj_perm.object_types.add(ContentType.objects.get_for_model(ScheduledJob))
-
-        # Give user1 delete_scheduledjob permission but not approve_job permission
-        obj_perm = ObjectPermission(name="Delete", actions=["delete"])
-        obj_perm.save()
-        obj_perm.users.add(user1)
-        obj_perm.object_types.add(ContentType.objects.get_for_model(ScheduledJob))
-
-        # Give user2 approve_job permission but not delete_scheduledjob permission
-        obj_perm = ObjectPermission(name="Approve", actions=["approve"])
-        obj_perm.save()
-        obj_perm.users.add(user2)
-        obj_perm.object_types.add(ContentType.objects.get_for_model(Job))
-
-        instance = self._get_queryset().first()
-        data = {"_deny": True}
-
-        for user in (user1, user2):
-            self.client.force_login(user)
-            response = self.client.post(self._get_url("view", instance), data)
-            self.assertBodyContains(response, "You do not have permission")
-            # Request was not deleted
-            self.assertEqual(1, len(ScheduledJob.objects.filter(pk=instance.pk)), msg=str(user))
-
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
-    @load_event_broker_override_settings(
-        EVENT_BROKERS={
-            "SyslogEventBroker": {
-                "CLASS": "nautobot.core.events.SyslogEventBroker",
-                "TOPICS": {
-                    "INCLUDE": ["*"],
-                },
-            }
-        }
-    )
-    def test_post_deny_different_user_permitted(self):
-        """A user with appropriate permissions can deny a job request."""
-        user = User.objects.create_user(username="testuser1")
-        instance = self._get_queryset().first()
-
-        # Give user view_scheduledjob and delete_scheduledjob permissions
-        obj_perm = ObjectPermission(name="View", actions=["view", "delete"], constraints={"pk": instance.pk})
-        obj_perm.save()
-        obj_perm.users.add(user)
-        obj_perm.object_types.add(ContentType.objects.get_for_model(ScheduledJob))
-
-        # Give user approve_job permission
-        obj_perm = ObjectPermission(name="Approve", actions=["approve"], constraints={"pk": instance.job_model.pk})
-        obj_perm.save()
-        obj_perm.users.add(user)
-        obj_perm.object_types.add(ContentType.objects.get_for_model(Job))
-
-        data = {"_deny": True}
-
-        self.client.force_login(user)
-        with self.assertLogs("nautobot.events") as cm:
-            response = self.client.post(self._get_url("view", instance), data)
-        self.assertRedirects(response, reverse("extras:scheduledjob_approval_queue_list"))
-        # Request was deleted
-        self.assertEqual(0, len(ScheduledJob.objects.filter(pk=instance.pk)))
-        # Event was published
-        expected_payload = {"data": serialize_object_v2(instance)}
-        self.assertEqual(
-            cm.output,
-            [
-                f"INFO:nautobot.events.nautobot.jobs.approval.denied:{json.dumps(expected_payload, cls=NautobotKombuJSONEncoder, indent=4)}"
-            ],
-        )
-
-        # Check object-based permissions are enforced for a different instance
-        instance = self._get_queryset().first()
-        response = self.client.post(self._get_url("view", instance), data)
-        self.assertBodyContains(response, "You do not have permission")
-        # Request was not deleted
-        self.assertEqual(1, len(ScheduledJob.objects.filter(pk=instance.pk)), msg=str(user))
-
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
-    def test_post_approve_cannot_self_approve(self):
-        self.add_permissions("extras.change_scheduledjob")
-        self.add_permissions("extras.approve_job")
-        instance = self._get_queryset().first()
-        data = {"_approve": True}
-
-        response = self.client.post(self._get_url("view", instance), data)
-        self.assertBodyContains(response, "You cannot approve your own job request")
-        # Job was not approved
-        instance.refresh_from_db()
-        self.assertIsNone(instance.approved_by_user)
-
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
-    def test_post_approve_different_user_lacking_permissions(self):
-        """A user needs both change_scheduledjob and approve_job permissions to approve a job request."""
-        user1 = User.objects.create_user(username="testuser1")
-        user2 = User.objects.create_user(username="testuser2")
-
-        # Give both users view_scheduledjob permission
-        obj_perm = ObjectPermission(name="View", actions=["view"])
-        obj_perm.save()
-        obj_perm.users.add(user1, user2)
-        obj_perm.object_types.add(ContentType.objects.get_for_model(ScheduledJob))
-
-        # Give user1 change_scheduledjob permission but not approve_job permission
-        obj_perm = ObjectPermission(name="Change", actions=["change"])
-        obj_perm.save()
-        obj_perm.users.add(user1)
-        obj_perm.object_types.add(ContentType.objects.get_for_model(ScheduledJob))
-
-        # Give user2 approve_job permission but not change_scheduledjob permission
-        obj_perm = ObjectPermission(name="Approve", actions=["approve"])
-        obj_perm.save()
-        obj_perm.users.add(user2)
-        obj_perm.object_types.add(ContentType.objects.get_for_model(Job))
-
-        instance = self._get_queryset().first()
-        data = {"_approve": True}
-
-        for user in (user1, user2):
-            self.client.force_login(user)
-            response = self.client.post(self._get_url("view", instance), data)
-            self.assertBodyContains(response, "You do not have permission")
-            # Job was not approved
-            instance.refresh_from_db()
-            self.assertIsNone(instance.approved_by_user)
-
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
-    @load_event_broker_override_settings(
-        EVENT_BROKERS={
-            "SyslogEventBroker": {
-                "CLASS": "nautobot.core.events.SyslogEventBroker",
-                "TOPICS": {
-                    "INCLUDE": ["*"],
-                },
-            }
-        }
-    )
-    def test_post_approve_different_user_permitted(self):
-        """A user with appropriate permissions can approve a job request."""
-        user = User.objects.create_user(username="testuser1")
-        instance = self._get_queryset().first()
-
-        # Give user view_scheduledjob and change_scheduledjob permissions
-        obj_perm = ObjectPermission(name="View", actions=["view", "change"], constraints={"pk": instance.pk})
-        obj_perm.save()
-        obj_perm.users.add(user)
-        obj_perm.object_types.add(ContentType.objects.get_for_model(ScheduledJob))
-
-        # Give user approve_job permission
-        obj_perm = ObjectPermission(name="Approve", actions=["approve"], constraints={"pk": instance.job_model.pk})
-        obj_perm.save()
-        obj_perm.users.add(user)
-        obj_perm.object_types.add(ContentType.objects.get_for_model(Job))
-
-        data = {"_approve": True}
-
-        self.client.force_login(user)
-        with self.assertLogs("nautobot.events") as cm:
-            response = self.client.post(self._get_url("view", instance), data)
-
-        self.assertRedirects(response, reverse("extras:scheduledjob_approval_queue_list"))
-        # Job was scheduled
-        instance.refresh_from_db()
-        self.assertEqual(instance.approved_by_user, user)
-        # Event was published
-        expected_payload = {"data": serialize_object_v2(instance)}
-        self.assertEqual(
-            cm.output,
-            [
-                f"INFO:nautobot.events.nautobot.jobs.approval.approved:{json.dumps(expected_payload, cls=NautobotKombuJSONEncoder, indent=4)}"
-            ],
-        )
-
-        # Check object-based permissions are enforced for a different instance
-        instance = self._get_queryset().last()
-        response = self.client.post(self._get_url("view", instance), data)
-        self.assertBodyContains(response, "You do not have permission")
-        # Job was not scheduled
-        instance.refresh_from_db()
-        self.assertIsNone(instance.approved_by_user)
-
-
-class JobQueueTestCase(ViewTestCases.PrimaryObjectViewTestCase):
-    model = JobQueue
-
-    @classmethod
-    def setUpTestData(cls):
-        cls.form_data = {
-            "name": "Test Job Queue",
-            "queue_type": JobQueueTypeChoices.TYPE_CELERY,
-            "description": "This is a very detailed description",
-            "tenant": Tenant.objects.first().pk,
-            "tags": [t.pk for t in Tag.objects.get_for_model(JobQueue)],
-        }
-        cls.bulk_edit_data = {
-            "queue_type": JobQueueTypeChoices.TYPE_KUBERNETES,
-            "description": "This is a very detailed new description",
-            "tenant": Tenant.objects.last().pk,
-            # TODO add tests for add_tags/remove_tags fields in TagsBulkEditFormMixin
-        }
-
-
-class JobResultTestCase(
-    ViewTestCases.GetObjectViewTestCase,
-    ViewTestCases.ListObjectsViewTestCase,
-    ViewTestCases.DeleteObjectViewTestCase,
-    ViewTestCases.BulkDeleteObjectsViewTestCase,
-):
-    model = JobResult
+class JobResultTestCase(
+    ViewTestCases.GetObjectViewTestCase,
+    ViewTestCases.ListObjectsViewTestCase,
+    ViewTestCases.DeleteObjectViewTestCase,
+    ViewTestCases.BulkDeleteObjectsViewTestCase,
+):
+    model = JobResult
 
     @classmethod
     def setUpTestData(cls):
@@ -2839,6 +2956,18 @@ class JobTestCase(
             reverse("extras:job_run", kwargs={"pk": cls.test_pass.pk}),
         )
 
+        cls.test_dryrun = Job.objects.get(job_class_name="TestDryRun")
+        cls.test_dryrun.enabled = True
+        cls.test_dryrun.has_sensitive_variables = False
+        cls.test_dryrun.save()
+
+        cls.run_urls_dryrun = (
+            # Legacy URL (job class path based)
+            reverse("extras:job_run_by_class_path", kwargs={"class_path": cls.test_dryrun.class_path}),
+            # Current URL (job model pk based)
+            reverse("extras:job_run", kwargs={"pk": cls.test_dryrun.pk}),
+        )
+
         cls.test_required_args = Job.objects.get(job_class_name="TestRequired")
         cls.test_required_args.enabled = True
         cls.test_pass.default_job_queue = default_job_queue
@@ -2882,8 +3011,6 @@ class JobTestCase(
             "dryrun_default": True,
             "hidden_override": True,
             "hidden": False,
-            "approval_required_override": True,
-            "approval_required": True,
             "soft_time_limit_override": True,
             "soft_time_limit": 350,
             "time_limit_override": True,
@@ -2905,8 +3032,6 @@ class JobTestCase(
             "dryrun_default": "",
             "clear_hidden_override": True,
             "hidden": False,
-            "clear_approval_required_override": True,
-            "approval_required": True,
             "clear_soft_time_limit_override": False,
             "soft_time_limit": 350,
             "clear_time_limit_override": True,
@@ -3151,7 +3276,8 @@ class JobTestCase(
             self.assertEqual(errors, ["var: This field is required."])
 
     @mock.patch("nautobot.extras.views.get_worker_count", return_value=1)
-    def test_run_now_with_args(self, _):
+    @mock.patch("nautobot.extras.models.mixins.ApprovableModelMixin.begin_approval_workflow")
+    def test_immediate_job_run_with_args_no_trigger_approval(self, mock_begin_approval_workflow, _):
         self.add_permissions("extras.run_job")
         self.add_permissions("extras.view_jobresult")
 
@@ -3165,6 +3291,7 @@ class JobTestCase(
 
             result = JobResult.objects.latest()
             self.assertRedirects(response, reverse("extras:jobresult", kwargs={"pk": result.pk}))
+            mock_begin_approval_workflow.assert_not_called()
 
     def test_rerun_job(self):
         self.add_permissions("extras.run_job")
@@ -3265,7 +3392,8 @@ class JobTestCase(
             )
 
     @mock.patch("nautobot.extras.views.get_worker_count", return_value=1)
-    def test_run_later(self, _):
+    @mock.patch("nautobot.extras.models.mixins.ApprovableModelMixin.begin_approval_workflow")
+    def test_run_later_triggers_approval_workflow(self, mock_begin_approval_workflow, _):
         self.add_permissions("extras.run_job")
         self.add_permissions("extras.view_scheduledjob")
 
@@ -3283,6 +3411,7 @@ class JobTestCase(
 
             scheduled = ScheduledJob.objects.get(name=f"test {i}")
             self.assertEqual(scheduled.start_time, start_time)
+        mock_begin_approval_workflow.assert_called()
 
     @mock.patch("nautobot.extras.views.get_worker_count", return_value=1)
     def test_run_job_with_sensitive_variables_for_future(self, _):
@@ -3329,69 +3458,221 @@ class JobTestCase(
             )
 
     @mock.patch("nautobot.extras.views.get_worker_count", return_value=1)
-    def test_run_job_with_sensitive_variables_and_requires_approval(self, _):
+    def test_run_job_with_sensitive_variables_and_approval_workflow_defined(self, _):
+        ApprovalWorkflowDefinition.objects.create(
+            name="Test Approval Workflow Definition 1",
+            model_content_type=ContentType.objects.get_for_model(ScheduledJob),
+            weight=0,
+        )
+
         self.add_permissions("extras.run_job")
         self.add_permissions("extras.view_scheduledjob")
 
         self.test_pass.has_sensitive_variables = True
-        self.test_pass.approval_required = True
         self.test_pass.save()
 
         data = {
             "_schedule_type": "immediately",
         }
         for run_url in self.run_urls:
-            # Assert warning message shows in get
-            response = self.client.get(run_url)
+            # Assert error message shows after post
+            response = self.client.post(run_url, data)
             self.assertBodyContains(
                 response,
-                "This job is flagged as possibly having sensitive variables but is also flagged as requiring approval.",
+                "Unable to run or schedule job: "
+                "This job is flagged as possibly having sensitive variables but also has an applicable approval workflow definition."
+                "Modify or remove the approval workflow definition or modify the job to set `has_sensitive_variables` to False.",
             )
 
-            # Assert run button is disabled
-            self.assertBodyContains(
+    @mock.patch("nautobot.extras.views.get_worker_count", return_value=1)
+    def test_run_immediate_job_triggers_approval_workflow_if_defined(self, _):
+        self.add_permissions("extras.run_job")
+        self.add_permissions("extras.view_scheduledjob")
+
+        ApprovalWorkflowDefinition.objects.create(
+            name="Approval Definition",
+            model_content_type=ContentType.objects.get_for_model(ScheduledJob),
+            weight=0,
+        )
+        data = {
+            "_schedule_type": "immediately",
+        }
+        for run_url in self.run_urls:
+            response = self.client.post(run_url, data)
+            scheduled_job = ScheduledJob.objects.last()
+            self.assertEqual(scheduled_job.interval, JobExecutionType.TYPE_FUTURE)
+            self.assertRedirects(
                 response,
-                """
-                <button type="submit" name="_run" id="id__run" class="btn btn-primary" disabled="disabled">
-                    <i class="mdi mdi-play"></i> Run Job Now
-                </button>
-                """,
-                html=True,
+                reverse("extras:scheduledjob_approvalworkflow", args=[scheduled_job.pk]),
             )
+
+    @mock.patch("nautobot.extras.views.get_worker_count", return_value=1)
+    def test_scheduled_job_triggers_approval_workflow_if_defined(self, _):
+        self.add_permissions("extras.run_job")
+        self.add_permissions("extras.view_scheduledjob")
+
+        ApprovalWorkflowDefinition.objects.create(
+            name="Approval Definition",
+            model_content_type=ContentType.objects.get_for_model(ScheduledJob),
+            weight=0,
+        )
+        data = {
+            "_schedule_type": "future",
+            "_schedule_name": "test",
+            "_schedule_start_time": str(timezone.now() + timedelta(minutes=1)),
+        }
+
+        for i, run_url in enumerate(self.run_urls):
+            if "_schedule_name" in data:
+                data["_schedule_name"] = f"test {i}"
+            response = self.client.post(run_url, data)
+            scheduled_job = ScheduledJob.objects.last()
+            self.assertRedirects(
+                response,
+                reverse("extras:scheduledjob_approvalworkflow", args=[scheduled_job.pk]),
+            )
+
+    @mock.patch("nautobot.extras.views.get_worker_count", return_value=1)
+    def test_run_scheduled_job_with_no_approval_workflow_defined(self, _):
+        self.add_permissions("extras.run_job")
+        self.add_permissions("extras.view_scheduledjob")
+
+        data = {
+            "_schedule_type": "future",
+            "_schedule_name": "test",
+            "_schedule_start_time": str(timezone.now() + timedelta(minutes=1)),
+        }
+
+        for i, run_url in enumerate(self.run_urls):
+            if "_schedule_name" in data:
+                data["_schedule_name"] = f"test {i}"
+            response = self.client.post(run_url, data)
+            scheduled_job = ScheduledJob.objects.last()
+            self.assertRedirects(response, reverse("extras:scheduledjob_list"))
+            self.assertFalse(scheduled_job.associated_approval_workflows.exists())
+
+    @mock.patch("nautobot.extras.views.get_worker_count", return_value=1)
+    def test_run_immediate_job_with_no_approval_workflow_definded(self, _):
+        self.add_permissions("extras.run_job")
+        self.add_permissions("extras.view_jobresult")
+
+        data = {
+            "_schedule_type": "immediately",
+        }
+
+        for run_url in self.run_urls:
+            response = self.client.post(run_url, data)
+            scheduled_job = ScheduledJob.objects.last()
+            self.assertIsNone(scheduled_job)
+            result = JobResult.objects.latest()
+            self.assertRedirects(response, reverse("extras:jobresult", kwargs={"pk": result.pk}))
+
+    @mock.patch("nautobot.extras.views.get_worker_count", return_value=1)
+    def test_run_dryrun_immediate_job_with_approval_workflow_definded(self, _):
+        self.add_permissions("extras.run_job")
+        self.add_permissions("extras.view_jobresult")
+
+        ApprovalWorkflowDefinition.objects.create(
+            name="Approval Definition",
+            model_content_type=ContentType.objects.get_for_model(ScheduledJob),
+            weight=0,
+        )
+
+        data = {
+            "_schedule_type": "immediately",
+            "dryrun": True,
+        }
+        for run_url in self.run_urls_dryrun:
+            response = self.client.post(run_url, data)
+            scheduled_job = ScheduledJob.objects.last()
+            self.assertIsNone(scheduled_job)
+            result = JobResult.objects.latest()
+            self.assertRedirects(response, reverse("extras:jobresult", kwargs={"pk": result.pk}))
+
+    @mock.patch("nautobot.extras.views.get_worker_count", return_value=1)
+    def test_run_dryrun_job_with_sensitive_variables_and_approval_workflow_defined(self, _):
+        self.test_dryrun.has_sensitive_variables = True
+        self.test_dryrun.save()
+
+        self.add_permissions("extras.run_job")
+        self.add_permissions("extras.view_jobresult")
+
+        ApprovalWorkflowDefinition.objects.create(
+            name="Approval Definition",
+            model_content_type=ContentType.objects.get_for_model(ScheduledJob),
+            weight=0,
+        )
+
+        data = {
+            "_schedule_type": "immediately",
+            "dryrun": True,
+        }
+
+        for run_url in self.run_urls_dryrun:
             # Assert error message shows after post
             response = self.client.post(run_url, data)
             self.assertBodyContains(
                 response,
                 "Unable to run or schedule job: "
-                "This job is flagged as possibly having sensitive variables but is also flagged as requiring approval."
-                "One of these two flags must be removed before this job can be scheduled or run.",
+                "This job is flagged as possibly having sensitive variables but also has an applicable approval workflow definition."
+                "Modify or remove the approval workflow definition or modify the job to set `has_sensitive_variables` to False.",
             )
 
     @mock.patch("nautobot.extras.views.get_worker_count", return_value=1)
-    def test_run_job_with_approval_required_creates_scheduled_job_internal_future(self, _):
+    def test_run_dryrun_schedule_job_with_approval_workflow_definded(self, _):
         self.add_permissions("extras.run_job")
         self.add_permissions("extras.view_scheduledjob")
 
-        self.test_pass.approval_required = True
-        self.test_pass.save()
+        ApprovalWorkflowDefinition.objects.create(
+            name="Approval Definition",
+            model_content_type=ContentType.objects.get_for_model(ScheduledJob),
+            weight=0,
+        )
         data = {
-            "_schedule_type": "immediately",
+            "_schedule_type": "future",
+            "_schedule_name": "test",
+            "_schedule_start_time": str(timezone.now() + timedelta(minutes=1)),
+            "dryrun": True,
         }
-        for run_url in self.run_urls:
+
+        for i, run_url in enumerate(self.run_urls_dryrun):
+            if "_schedule_name" in data:
+                data["_schedule_name"] = f"test {i}"
             response = self.client.post(run_url, data)
             scheduled_job = ScheduledJob.objects.last()
-            self.assertTrue(scheduled_job.interval, JobExecutionType.TYPE_FUTURE)
             self.assertRedirects(
                 response,
-                reverse("extras:scheduledjob_approval_queue_list"),
+                reverse("extras:scheduledjob_approvalworkflow", args=[scheduled_job.pk]),
             )
 
+    @mock.patch("nautobot.extras.views.get_worker_count", return_value=1)
+    def test_run_dryrun_schedule_job_with_no_approval_workflow_definded(self, _):
+        self.add_permissions("extras.run_job")
+        self.add_permissions("extras.view_scheduledjob")
+
+        data = {
+            "_schedule_type": "future",
+            "_schedule_name": "test",
+            "_schedule_start_time": str(timezone.now() + timedelta(minutes=1)),
+            "dryrun": True,
+        }
+
+        for i, run_url in enumerate(self.run_urls_dryrun):
+            if "_schedule_name" in data:
+                data["_schedule_name"] = f"test {i}"
+            response = self.client.post(run_url, data)
+            scheduled_job = ScheduledJob.objects.last()
+            self.assertRedirects(response, reverse("extras:scheduledjob_list"))
+            self.assertFalse(scheduled_job.associated_approval_workflows.exists())
+
     def test_job_object_change_log_view(self):
         """Assert Job change log view displays appropriate header"""
         instance = self.test_pass
         self.add_permissions("extras.view_objectchange", "extras.view_job")
         response = self.client.get(instance.get_changelog_url())
-        self.assertBodyContains(response, f"{instance.name} - Change Log")
+        self.assertBodyContains(response, f"{instance}")
+        changelog_table = "<thead><tr><th>Time</th><th>User name</th><th>Action</th><th>Type</th><th>Object</th><th>Request ID</th></tr></thead>"
+        self.assertBodyContains(response, changelog_table, html=True)
 
 
 class JobButtonTestCase(
@@ -3566,8 +3847,9 @@ class JobButtonRenderingTestCase(TestCase):
                 NO_CONFIRM_BUTTON.format(
                     button_id=self.job_button_1.pk,
                     button_text=f"JobButton {self.location_type.name}",
-                    button_class=self.job_button_1.button_class,
+                    button_class=self.job_button_1.button_class_css_class,
                     disabled="",
+                    menu_item="",
                 ),
                 content,
             )
@@ -3575,8 +3857,9 @@ class JobButtonRenderingTestCase(TestCase):
                 NO_CONFIRM_BUTTON.format(
                     button_id=self.job_button_2.pk,
                     button_text="Click me!",
-                    button_class=self.job_button_2.button_class,
+                    button_class=self.job_button_2.button_class_css_class,
                     disabled="disabled",
+                    menu_item="",
                 ),
                 content,
             )
@@ -3597,6 +3880,7 @@ class JobButtonRenderingTestCase(TestCase):
                     button_text=f"JobButton {self.location_type.name}",
                     button_class="link",
                     disabled="",
+                    menu_item="dropdown-item",
                 )
                 + "</li>",
                 content,
@@ -3608,12 +3892,14 @@ class JobButtonRenderingTestCase(TestCase):
                     button_text="Click me!",
                     button_class="link",
                     disabled="disabled",
+                    menu_item="dropdown-item",
                 )
                 + "</li>",
                 content,
             )
 
 
+@tag("example_app")
 class JobCustomTemplateTestCase(TestCase):
     @classmethod
     def setUpTestData(cls):
@@ -4160,9 +4446,9 @@ class TagTestCase(ViewTestCases.OrganizationalObjectViewTestCase):
         }
         self.assertHttpStatus(self.client.post(**request), 302)
 
-        tag = Tag.objects.filter(name=self.form_data["name"])
-        self.assertTrue(tag.exists())
-        self.assertEqual(tag[0].content_types.first(), location_content_type)
+        tag_object = Tag.objects.filter(name=self.form_data["name"])
+        self.assertTrue(tag_object.exists())
+        self.assertEqual(tag_object[0].content_types.first(), location_content_type)
 
     def test_create_tags_with_invalid_content_types(self):
         self.add_permissions("extras.add_tag")
@@ -4179,8 +4465,8 @@ class TagTestCase(ViewTestCases.OrganizationalObjectViewTestCase):
         }
 
         response = self.client.post(**request)
-        tag = Tag.objects.filter(name=self.form_data["name"])
-        self.assertFalse(tag.exists())
+        tag_object = Tag.objects.filter(name=self.form_data["name"])
+        self.assertFalse(tag_object.exists())
         self.assertBodyContains(response, "content_types: Select a valid choice")
 
     def test_update_tags_remove_content_type(self):
@@ -4306,6 +4592,7 @@ class RoleTestCase(ViewTestCases.OrganizationalObjectViewTestCase, ViewTestCases
             "remove_content_types": [device_ct.pk],
         }
 
+    @tag("fix_in_v3")
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_view_with_content_types(self):
         """
@@ -4325,12 +4612,12 @@ class RoleTestCase(ViewTestCases.OrganizationalObjectViewTestCase, ViewTestCases
                     if result == "Contact Associations":
                         # AssociationContact Table in the contact tab should be there.
                         self.assertInHTML(
-                            f'<strong>{result}</strong><div class="pull-right noprint">',
+                            f'<strong>{result}</strong><div class="float-end d-print-none">',
                             response_body,
                         )
                         # ContactAssociationTable related to this role instances should not be there.
                         self.assertNotIn(
-                            f'<strong>{result}</strong>\n            </div>\n            \n\n<table class="table table-hover table-headings">\n',
+                            f'<strong>{result}</strong>\n            </div>\n            \n\n<table class="table table-hover nb-table-headings">\n',
                             response_body,
                         )
                     else: