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

nautobot/extras/tests/test_models.py

@@ -4,18 +4,17 @@ import shutil
 import tempfile
 from unittest import expectedFailure, mock
 import uuid
-import warnings
 from zoneinfo import ZoneInfo
 
 from django.conf import settings
 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.core.files.uploadedfile import SimpleUploadedFile
 from django.db.models import ProtectedError
 from django.db.utils import IntegrityError
-from django.test import override_settings
-from django.test.utils import isolate_apps
+from django.test import override_settings, tag
 from django.utils.timezone import get_default_timezone, now
 from django_celery_beat.tzcrontab import TzAwareCrontab
 from git import GitCommandError
@@ -35,6 +34,7 @@ from nautobot.dcim.models import (
     Platform,
 )
 from nautobot.extras.choices import (
+    ApprovalWorkflowStateChoices,
     JobExecutionType,
     JobResultStatusChoices,
     LogLevelChoices,
@@ -53,6 +53,11 @@ from nautobot.extras.constants import (
 from nautobot.extras.datasources.registry import get_datasource_contents
 from nautobot.extras.jobs import get_job
 from nautobot.extras.models import (
+    ApprovalWorkflow,
+    ApprovalWorkflowDefinition,
+    ApprovalWorkflowStage,
+    ApprovalWorkflowStageDefinition,
+    ApprovalWorkflowStageResponse,
     ComputedField,
     ConfigContext,
     ConfigContextSchema,
@@ -83,7 +88,6 @@ from nautobot.extras.models import (
     Team,
     Webhook,
 )
-from nautobot.extras.models.statuses import StatusModel
 from nautobot.extras.registry import registry
 from nautobot.extras.secrets.exceptions import SecretParametersError, SecretProviderError, SecretValueNotFoundError
 from nautobot.extras.tests.git_helper import create_and_populate_git_repository
@@ -96,11 +100,242 @@ from nautobot.virtualization.models import (
     VirtualMachine,
 )
 
-from example_app.jobs import ExampleJob
-
 User = get_user_model()
 
 
+class ApprovalWorkflowTest(ModelTestCases.BaseModelTestCase):
+    """
+    Tests for the ApprovalWorkflow model class.
+    """
+
+    model = ApprovalWorkflow
+
+    @classmethod
+    def setUpTestData(cls):
+        # Prepare the test data
+        cls.scheduledjob_ct = ContentType.objects.get_for_model(ScheduledJob)
+        cls.approver_group_1 = Group.objects.create(name="Approver Group 1")
+        cls.approver_group_2 = Group.objects.create(name="Approver Group 2")
+        cls.approver_group_3 = Group.objects.create(name="Approver Group 3")
+        cls.users = (
+            User.objects.create(username="User 1", is_active=True),
+            User.objects.create(username="User 2", is_active=True),
+            User.objects.create(username="User 3", is_active=True, is_superuser=True),
+            User.objects.create(username="User 4", is_active=True),
+            User.objects.create(username="User 5", is_active=True),
+        )
+        job_model = JobModel.objects.get_for_class_path("pass_job.TestPassJob")
+        cls.scheduled_job = ScheduledJob.objects.create(
+            name="Test Pass Scheduled Job",
+            task="pass_job.TestPassJob",
+            job_model=job_model,
+            interval=JobExecutionType.TYPE_IMMEDIATELY,
+            user=cls.users[0],
+            start_time=now(),
+        )
+        cls.approver_group_1.user_set.set([cls.users[0]])
+        cls.approver_group_2.user_set.set([cls.users[1], cls.users[2]])
+        cls.approver_group_3.user_set.set([cls.users[3], cls.users[4]])
+
+        # Create an Approval Workflow Definition
+        cls.approval_workflow_definition = ApprovalWorkflowDefinition.objects.create(
+            name="Approval Workflow with Three Stages",
+            model_content_type=cls.scheduledjob_ct,
+            weight=1,
+        )
+        # Create three stages of the Approval Workflow Definition
+        cls.approval_workflow_stage_definition_1 = ApprovalWorkflowStageDefinition.objects.create(
+            approval_workflow_definition=cls.approval_workflow_definition,
+            sequence=100,
+            name="Approval Workflow Stage Definition 1",
+            min_approvers=1,
+            denial_message="Stage 1 Denial Message",
+            approver_group=cls.approver_group_1,
+        )
+        cls.approval_workflow_stage_definition_2 = ApprovalWorkflowStageDefinition.objects.create(
+            approval_workflow_definition=cls.approval_workflow_definition,
+            sequence=200,
+            name="Approval Workflow Stage Definition 2",
+            min_approvers=2,
+            denial_message="Stage 2 Denial Message",
+            approver_group=cls.approver_group_2,
+        )
+        cls.approval_workflow_stage_definition_3 = ApprovalWorkflowStageDefinition.objects.create(
+            approval_workflow_definition=cls.approval_workflow_definition,
+            sequence=300,
+            name="Approval Workflow Stage Definition 3",
+            min_approvers=2,
+            denial_message="Stage 3 Denial Message",
+            approver_group=cls.approver_group_3,
+        )
+
+        # Create an Approval Workflow
+        cls.approval_workflow = ApprovalWorkflow.objects.create(
+            approval_workflow_definition=cls.approval_workflow_definition,
+            object_under_review_content_type=cls.scheduledjob_ct,
+            object_under_review_object_id=cls.scheduled_job.pk,
+            current_state=ApprovalWorkflowStateChoices.PENDING,
+        )
+        # Create three Approval Workflow Stage Instances
+        cls.approval_workflow_stage_1 = ApprovalWorkflowStage.objects.create(
+            approval_workflow=cls.approval_workflow,
+            approval_workflow_stage_definition=cls.approval_workflow_stage_definition_1,
+            state=ApprovalWorkflowStateChoices.PENDING,
+        )
+        cls.approval_workflow_stage_2 = ApprovalWorkflowStage.objects.create(
+            approval_workflow=cls.approval_workflow,
+            approval_workflow_stage_definition=cls.approval_workflow_stage_definition_2,
+            state=ApprovalWorkflowStateChoices.PENDING,
+        )
+        cls.approval_workflow_stage_3 = ApprovalWorkflowStage.objects.create(
+            approval_workflow=cls.approval_workflow,
+            approval_workflow_stage_definition=cls.approval_workflow_stage_definition_3,
+            state=ApprovalWorkflowStateChoices.PENDING,
+        )
+        # Create five Approval Workflow Stage Instance Response
+        cls.approval_workflow_stage_1_response_1 = ApprovalWorkflowStageResponse.objects.create(
+            approval_workflow_stage=cls.approval_workflow_stage_1,
+            user=cls.users[0],
+            state=ApprovalWorkflowStateChoices.PENDING,
+        )
+        cls.approval_workflow_stage_2_response_1 = ApprovalWorkflowStageResponse.objects.create(
+            approval_workflow_stage=cls.approval_workflow_stage_2,
+            user=cls.users[1],
+            state=ApprovalWorkflowStateChoices.PENDING,
+        )
+        cls.approval_workflow_stage_2_response_2 = ApprovalWorkflowStageResponse.objects.create(
+            approval_workflow_stage=cls.approval_workflow_stage_2,
+            user=cls.users[2],
+            state=ApprovalWorkflowStateChoices.PENDING,
+        )
+        cls.approval_workflow_stage_3_response_1 = ApprovalWorkflowStageResponse.objects.create(
+            approval_workflow_stage=cls.approval_workflow_stage_3,
+            user=cls.users[3],
+            state=ApprovalWorkflowStateChoices.PENDING,
+        )
+        cls.approval_workflow_stage_3_response_2 = ApprovalWorkflowStageResponse.objects.create(
+            approval_workflow_stage=cls.approval_workflow_stage_3,
+            user=cls.users[4],
+            state=ApprovalWorkflowStateChoices.PENDING,
+        )
+
+    def test_active_stage_property(self):
+        """
+        Test the active_stage property of the ApprovalWorkflow model.
+        """
+        # Test that the active stage is the one with the lowest sequence when all stages are pending
+        self.assertEqual(self.approval_workflow.active_stage, self.approval_workflow_stage_1)
+        # Test that the active stage is the second stage when the first stage is approved
+        self.approval_workflow_stage_1_response_1.state = ApprovalWorkflowStateChoices.APPROVED
+        self.approval_workflow_stage_1_response_1.save()
+        self.assertEqual(self.approval_workflow_stage_1.state, ApprovalWorkflowStateChoices.APPROVED)
+        self.assertIsNotNone(self.approval_workflow_stage_1.decision_date)
+        self.assertEqual(self.approval_workflow.active_stage, self.approval_workflow_stage_2)
+        # Test that the active stage remains the second stage when the second stage is denied
+        self.approval_workflow_stage_2_response_1.state = ApprovalWorkflowStateChoices.DENIED
+        self.approval_workflow_stage_2_response_1.save()
+        self.assertEqual(self.approval_workflow_stage_2.state, ApprovalWorkflowStateChoices.DENIED)
+        self.assertIsNotNone(self.approval_workflow_stage_2.decision_date)
+        self.assertEqual(self.approval_workflow.active_stage, self.approval_workflow_stage_2)
+        self.assertEqual(self.approval_workflow.current_state, ApprovalWorkflowStateChoices.DENIED)
+
+    def test_approval_workflow_workflow_all_stages_are_approved(self):
+        """
+        Test the logic when all stage instances of an approval workflow are approved.
+        """
+        # One user approves the first stage
+        self.approval_workflow_stage_1_response_1.state = ApprovalWorkflowStateChoices.APPROVED
+        self.approval_workflow_stage_1_response_1.save()
+        # Minimum approvers for the first stage is 1, so the stage should be approved
+        self.assertEqual(self.approval_workflow_stage_1.state, ApprovalWorkflowStateChoices.APPROVED)
+        self.assertIsNotNone(self.approval_workflow_stage_1.decision_date)
+        # Approval Workflow Instance should still be pending, stage 2 and stage 3 are not approved yet
+        self.assertEqual(self.approval_workflow.current_state, ApprovalWorkflowStateChoices.PENDING)
+        # The active stage should be the second stage now
+        self.assertEqual(self.approval_workflow.active_stage, self.approval_workflow_stage_2)
+
+        # Two users approved the second stage
+        self.approval_workflow_stage_2_response_1.state = ApprovalWorkflowStateChoices.APPROVED
+        self.approval_workflow_stage_2_response_1.save()
+        self.approval_workflow_stage_2_response_2.state = ApprovalWorkflowStateChoices.APPROVED
+        self.approval_workflow_stage_2_response_2.save()
+        # Minimum approvers for the second stage is 2, so the stage should be approved
+        self.assertEqual(self.approval_workflow_stage_2.state, ApprovalWorkflowStateChoices.APPROVED)
+        self.assertIsNotNone(self.approval_workflow_stage_2.decision_date)
+        # Approval Workflow Instance should still be pending, stage 3 is not approved yet
+        self.assertEqual(self.approval_workflow.current_state, ApprovalWorkflowStateChoices.PENDING)
+        # The active stage should be the third stage now
+        self.assertEqual(self.approval_workflow.active_stage, self.approval_workflow_stage_3)
+
+        # Two users approved the third stage
+        self.approval_workflow_stage_3_response_1.state = ApprovalWorkflowStateChoices.APPROVED
+        self.approval_workflow_stage_3_response_1.save()
+        self.approval_workflow_stage_3_response_2.state = ApprovalWorkflowStateChoices.APPROVED
+        self.approval_workflow_stage_3_response_2.save()
+        # Minimum approvers for the third stage is 2, so the stage should be approved
+        self.assertEqual(self.approval_workflow_stage_3.state, ApprovalWorkflowStateChoices.APPROVED)
+        self.assertIsNotNone(self.approval_workflow_stage_3.decision_date)
+        # Approval Workflow Instance should be approved since all stages are approved
+        self.assertEqual(self.approval_workflow.current_state, ApprovalWorkflowStateChoices.APPROVED)
+        # No more stages to approve, so the active stage is now None
+        # and its decision date is updated because a terminal state has been reached
+        self.assertEqual(self.approval_workflow.active_stage, None)
+        self.assertIsNotNone(self.approval_workflow.decision_date)
+
+    def test_approval_workflow_one_stage_is_denied(self):
+        """
+        Test the logic when one of the stages of an approval workflow is denied.
+        """
+        # One user approves the first stage
+        self.approval_workflow_stage_1_response_1.state = ApprovalWorkflowStateChoices.APPROVED
+        self.approval_workflow_stage_1_response_1.save()
+        # Minimum approvers for the first stage is 1, so the stage should be approved
+        self.assertEqual(self.approval_workflow_stage_1.state, ApprovalWorkflowStateChoices.APPROVED)
+        self.assertIsNotNone(self.approval_workflow_stage_1.decision_date)
+        # Approval Workflow Instance should still be pending
+        self.assertEqual(self.approval_workflow.current_state, ApprovalWorkflowStateChoices.PENDING)
+        # The active stage should be the second stage now
+        self.assertEqual(self.approval_workflow.active_stage, self.approval_workflow_stage_2)
+
+        # One user approved the second stage while another user denies it
+        self.approval_workflow_stage_2_response_1.state = ApprovalWorkflowStateChoices.APPROVED
+        self.approval_workflow_stage_2_response_1.save()
+        self.approval_workflow_stage_2_response_2.state = ApprovalWorkflowStateChoices.DENIED
+        self.approval_workflow_stage_2_response_2.save()
+        # One user denies the stage, so the stage should be denied
+        self.assertEqual(self.approval_workflow_stage_2.state, ApprovalWorkflowStateChoices.DENIED)
+        self.assertIsNotNone(self.approval_workflow_stage_2.decision_date)
+        # Approval Workflow Instance should be denied since one stage is denied
+        # and its decision date is updated because a terminal state has been reached
+        self.assertEqual(self.approval_workflow.current_state, ApprovalWorkflowStateChoices.DENIED)
+        self.assertIsNotNone(self.approval_workflow.decision_date)
+        # The active stage should remain the second stage that is denied
+        self.assertEqual(self.approval_workflow.active_stage, self.approval_workflow_stage_2)
+
+    def test_approval_workflow_and_approval_workflow_definition_contenttype_mismatch(self):
+        # Create a Approval Workflow
+        scheduled_job_ct = ContentType.objects.get_for_model(ScheduledJob)
+        approval_workflow_definition = ApprovalWorkflowDefinition.objects.create(
+            name="Scheduled Job Approval Workflow",
+            model_content_type=scheduled_job_ct,
+            weight=2,
+        )
+        approval_workflow = ApprovalWorkflow(
+            approval_workflow_definition=approval_workflow_definition,
+            object_under_review_content_type=ContentType.objects.get_for_model(JobModel),
+            object_under_review_object_id=JobModel.objects.last().pk,
+        )
+
+        with self.assertRaises(ValidationError) as cm:
+            approval_workflow.save()
+
+        self.assertIn(
+            f"The content type {approval_workflow.object_under_review_content_type} of "
+            f"the object under review does not match the content type {approval_workflow_definition.model_content_type} of the approval workflow definition.",
+            str(cm.exception),
+        )
+
+
 class ComputedFieldTest(ModelTestCases.BaseModelTestCase):
     """
     Tests for the `ComputedField` Model
@@ -551,6 +786,21 @@ class ConfigContextTest(ModelTestCases.BaseModelTestCase):
             name="dynamic group", weight=100, data={"dynamic_group": 1}
         )
         dynamic_group_context.dynamic_groups.add(self.dynamic_groups)
+        cluster_group = ClusterGroup.objects.create(name="Cluster Group")
+        cluster_group_context = ConfigContext.objects.create(
+            name="cluster group", weight=100, data={"cluster_group": 1}
+        )
+        cluster_group_context.cluster_groups.add(cluster_group)
+        cluster_type = ClusterType.objects.create(name="Cluster Type 1")
+        cluster = Cluster.objects.create(
+            name="Cluster",
+            cluster_group=cluster_group,
+            cluster_type=cluster_type,
+            location=self.location,
+            tenant=self.tenant,
+        )
+        cluster_context = ConfigContext.objects.create(name="cluster", weight=100, data={"cluster": 1})
+        cluster_context.clusters.add(cluster)
 
         device = Device.objects.create(
             name="Device 2",
@@ -562,11 +812,21 @@ class ConfigContextTest(ModelTestCases.BaseModelTestCase):
             device_type=self.devicetype,
         )
         device.tags.add(self.tag)
+        device.clusters.add(cluster)
 
         annotated_queryset = Device.objects.filter(name=device.name).annotate_config_context_data()
         device_context = device.get_config_context()
         self.assertEqual(device_context, annotated_queryset[0].get_config_context())
-        for key in ["location", "platform", "tenant_group", "tenant", "tag", "dynamic_group"]:
+        for key in [
+            "location",
+            "platform",
+            "tenant_group",
+            "tenant",
+            "tag",
+            "dynamic_group",
+            "cluster_group",
+            "cluster",
+        ]:
             self.assertIn(key, device_context)
         # Add a device type constraint that does not match the device in question to the location config context
         # And make sure that location_context is not applied to it anymore.
@@ -795,9 +1055,9 @@ class ConfigContextTest(ModelTestCases.BaseModelTestCase):
     def test_multiple_tags_return_distinct_objects_with_seperate_config_contexts(self):
         """
         Tagged items use a generic relationship, which results in duplicate rows being returned when queried.
-        This is combatted by by appending distinct() to the config context querysets. This test creates a config
-        context assigned to two tags and ensures objects related by those same two tags result in only a single
-        config context record being returned.
+        This is combatted by by appending distinct() to the config context querysets. This test creates two config
+        contexts assigned to two different tags and ensures objects related by those same two tags result in both
+        config context records being returned.
 
         This test case is seperate from the above in that it deals with multiple config context objects in play.
 
@@ -859,6 +1119,104 @@ class ConfigContextTest(ModelTestCases.BaseModelTestCase):
         self.assertIn("dynamic context 2", device2.get_config_context().values())
         self.assertNotIn("dynamic context 1", device2.get_config_context().values())
 
+    def test_multiple_clusters_and_cluster_groups(self):
+        """
+        Device-to-cluster is a many-to-many relationship since Nautobot 3.0. Make sure things work as expected here.
+        """
+        cluster_group_1 = ClusterGroup.objects.create(name="Cluster Group 1")
+        cluster_type = ClusterType.objects.create(name="Cluster Type 1")
+        cluster_1 = Cluster.objects.create(
+            name="Cluster 1",
+            cluster_group=cluster_group_1,
+            cluster_type=cluster_type,
+            location=self.location,
+        )
+        cluster_group_2 = ClusterGroup.objects.create(name="Cluster Group 2")
+        cluster_2 = Cluster.objects.create(
+            name="Cluster 2",
+            cluster_group=cluster_group_2,
+            cluster_type=cluster_type,
+            location=self.location,
+        )
+        cluster_context_1 = ConfigContext.objects.create(name="cluster_1", weight=100, data={"cluster_1": 1})
+        cluster_context_1.clusters.add(cluster_1)
+        cluster_context_2 = ConfigContext.objects.create(name="cluster_2", weight=200, data={"cluster_2": 2})
+        cluster_context_2.clusters.add(cluster_2)
+        cluster_context_12 = ConfigContext.objects.create(name="cluster_12", weight=300, data={"cluster_12": [1, 2]})
+        cluster_context_12.clusters.add(cluster_1)
+        cluster_context_12.clusters.add(cluster_2)
+        cluster_group_context_1 = ConfigContext.objects.create(
+            name="cluster_group_1", weight=1100, data={"cluster_group_1": 1}
+        )
+        cluster_group_context_1.cluster_groups.add(cluster_group_1)
+        cluster_group_context_2 = ConfigContext.objects.create(
+            name="cluster_group_2", weight=1200, data={"cluster_group_2": 2}
+        )
+        cluster_group_context_2.cluster_groups.add(cluster_group_2)
+        cluster_group_context_12 = ConfigContext.objects.create(
+            name="cluster_group_12", weight=1300, data={"cluster_group_12": [1, 2]}
+        )
+        cluster_group_context_12.cluster_groups.add(cluster_group_1)
+        cluster_group_context_12.cluster_groups.add(cluster_group_2)
+
+        device = Device.objects.create(
+            name="Device Clusters",
+            location=self.location,
+            tenant=self.tenant,
+            platform=self.platform,
+            role=self.devicerole,
+            status=self.device_status,
+            device_type=self.devicetype,
+        )
+
+        with self.subTest("Device in single cluster"):
+            device.clusters.add(cluster_1)
+
+            self.assertEqual(ConfigContext.objects.get_for_object(device).count(), 5)  # including one from setUp()
+            context = device.get_config_context()
+            self.assertIn("cluster_1", context.keys())
+            self.assertNotIn("cluster_2", context.keys())
+            self.assertIn("cluster_12", context.keys())
+            self.assertIn("cluster_group_1", context.keys())
+            self.assertNotIn("cluster_group_2", context.keys())
+            self.assertIn("cluster_group_12", context.keys())
+
+        with self.subTest("Device in multiple clusters"):
+            device.clusters.add(cluster_2)
+
+            self.assertEqual(ConfigContext.objects.get_for_object(device).count(), 7)  # including one from setUp()
+            context = device.get_config_context()
+            self.assertIn("cluster_1", context.keys())
+            self.assertIn("cluster_2", context.keys())
+            self.assertIn("cluster_12", context.keys())
+            self.assertIn("cluster_group_1", context.keys())
+            self.assertIn("cluster_group_2", context.keys())
+            self.assertIn("cluster_group_12", context.keys())
+
+        with self.subTest("Device in single cluster again"):
+            device.clusters.remove(cluster_1)
+
+            self.assertEqual(ConfigContext.objects.get_for_object(device).count(), 5)  # including one from setUp()
+            context = device.get_config_context()
+            self.assertNotIn("cluster_1", context.keys())
+            self.assertIn("cluster_2", context.keys())
+            self.assertIn("cluster_12", context.keys())
+            self.assertNotIn("cluster_group_1", context.keys())
+            self.assertIn("cluster_group_2", context.keys())
+            self.assertIn("cluster_group_12", context.keys())
+
+        with self.subTest("Device in no clusters"):
+            device.clusters.remove(cluster_2)
+
+            self.assertEqual(ConfigContext.objects.get_for_object(device).count(), 1)  # including one from setUp()
+            context = device.get_config_context()
+            self.assertNotIn("cluster_1", context.keys())
+            self.assertNotIn("cluster_2", context.keys())
+            self.assertNotIn("cluster_12", context.keys())
+            self.assertNotIn("cluster_group_1", context.keys())
+            self.assertNotIn("cluster_group_2", context.keys())
+            self.assertNotIn("cluster_group_12", context.keys())
+
 
 class ConfigContextSchemaTestCase(ModelTestCases.BaseModelTestCase):
     """
@@ -1598,6 +1956,7 @@ class GitRepositoryTest(ModelTestCases.BaseModelTestCase):
             shutil.rmtree(self.tempdir.name, ignore_errors=True)
 
 
+@tag("example_app")
 class JobModelTest(ModelTestCases.BaseModelTestCase):
     """
     Tests for the `Job` model class.
@@ -1613,6 +1972,8 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
         cls.app_job = JobModel.objects.get(job_class_name="ExampleJob")
 
     def test_job_class(self):
+        from example_app.jobs import ExampleJob
+
         self.assertIsNotNone(self.local_job.job_class)
         self.assertEqual(self.local_job.job_class.description, "Validate job import")
 
@@ -1682,7 +2043,6 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
             "description": "Overridden Description",
             "dryrun_default": not self.job_containing_sensitive_variables.dryrun_default,
             "hidden": not self.job_containing_sensitive_variables.hidden,
-            "approval_required": not self.job_containing_sensitive_variables.approval_required,
             "has_sensitive_variables": not self.job_containing_sensitive_variables.has_sensitive_variables,
             "soft_time_limit": 350,
             "time_limit": 650,
@@ -1749,20 +2109,6 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
             ).clean()
         self.assertIn("Name", str(handler.exception))
 
-        with self.assertRaises(ValidationError) as handler:
-            JobModel(
-                module_name="module_name",
-                job_class_name="JobClassName",
-                grouping="grouping",
-                has_sensitive_variables=True,
-                approval_required=True,
-                name="Job Class Name",
-            ).clean()
-        self.assertEqual(
-            handler.exception.message_dict["approval_required"][0],
-            "A job that may have sensitive variables cannot be marked as requiring approval",
-        )
-
     def test_default_job_queue_always_included_in_job_queues(self):
         default_job_queue = JobQueue.objects.first()
         job_queues = list(JobQueue.objects.exclude(pk=default_job_queue.pk))[:3]
@@ -2262,19 +2608,20 @@ class ObjectMetadataTest(ModelTestCases.BaseModelTestCase):
         """
         Test that overlapping scoped_fields of ObjectMetadata with same metadata_type/assigned_object is not allowed.
         """
+        ip = IPAddress.objects.filter(associated_object_metadata__isnull=True).first()
         ObjectMetadata.objects.create(
             metadata_type=MetadataType.objects.first(),
             contact=Contact.objects.first(),
             scoped_fields=["host", "mask_length", "type", "role", "status"],
             assigned_object_type=ContentType.objects.get_for_model(IPAddress),
-            assigned_object_id=IPAddress.objects.filter(associated_object_metadata__isnull=True).first().pk,
+            assigned_object_id=ip.pk,
         )
         instance2 = ObjectMetadata.objects.create(
             metadata_type=MetadataType.objects.first(),
             contact=Contact.objects.first(),
-            scoped_fields=[],
+            scoped_fields=[],  # permitted for now because we skipped calling clean()/validated_save()
             assigned_object_type=ContentType.objects.get_for_model(IPAddress),
-            assigned_object_id=IPAddress.objects.filter(associated_object_metadata__isnull=True).first().pk,
+            assigned_object_id=ip.pk,
         )
         with self.assertRaises(ValidationError):
             # try scope all fields
@@ -3146,31 +3493,15 @@ class StatusTest(ModelTestCases.BaseModelTestCase):
             self.status.save()
             self.assertEqual(str(self.status), test)
 
-    @isolate_apps("nautobot.extras.tests")
-    def test_deprecated_mixin_class(self):
-        """Test that inheriting from StatusModel raises a DeprecationWarning."""
-        with warnings.catch_warnings(record=True) as warn_list:
-            warnings.simplefilter("always")
-
-            class MyModel(StatusModel):  # pylint: disable=unused-variable
-                pass
-
-        self.assertEqual(len(warn_list), 1)
-        warning = warn_list[0]
-        self.assertTrue(issubclass(warning.category, DeprecationWarning))
-        self.assertIn("StatusModel is deprecated", str(warning))
-        self.assertIn("Instead of deriving MyModel from StatusModel", str(warning))
-        self.assertIn("please directly declare `status = StatusField(...)` on your model instead", str(warning))
-
 
 class TagTest(ModelTestCases.BaseModelTestCase):
     model = Tag
 
     def test_create_tag_unicode(self):
-        tag = Tag(name="Testing Unicode: 台灣")
-        tag.save()
+        instance = Tag(name="Testing Unicode: 台灣")
+        instance.save()
 
-        self.assertEqual(tag.name, "Testing Unicode: 台灣")
+        self.assertEqual(instance.name, "Testing Unicode: 台灣")
 
 
 class JobLogEntryTest(TestCase):  # TODO: change to BaseModelTestCase