nautobot 2.0.0a2__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

nautobot/extras/tests/test_filters.py

@@ -79,7 +79,7 @@ from nautobot.extras.models import (
     Webhook,
 )
 from nautobot.ipam.filters import VLANFilterSet
-from nautobot.ipam.models import IPAddress, VLAN
+from nautobot.ipam.models import IPAddress, VLAN, Namespace, Prefix
 from nautobot.tenancy.models import Tenant, TenantGroup
 from nautobot.virtualization.models import Cluster, ClusterGroup, ClusterType, VirtualMachine
 
@@ -95,7 +95,7 @@ class ComputedFieldTestCase(FilterTestCases.FilterTestCase):
     def setUpTestData(cls):
         ComputedField.objects.create(
             content_type=ContentType.objects.get_for_model(Location),
-            slug="computed_field_one",
+            key="computed_field_one",
             label="Computed Field One",
             template="{{ obj.name }} is the name of this location.",
             fallback_value="An error occurred while rendering this template.",
@@ -104,7 +104,7 @@ class ComputedFieldTestCase(FilterTestCases.FilterTestCase):
         # Field whose template will raise a TemplateError
         ComputedField.objects.create(
             content_type=ContentType.objects.get_for_model(Location),
-            slug="bad_computed_field",
+            key="bad_computed_field",
             label="Bad Computed Field",
             template="{{ something_that_throws_an_err | not_a_real_filter }} bad data",
             fallback_value="This template has errored",
@@ -113,7 +113,7 @@ class ComputedFieldTestCase(FilterTestCases.FilterTestCase):
         # Field whose template will raise a TypeError
         ComputedField.objects.create(
             content_type=ContentType.objects.get_for_model(Location),
-            slug="worse_computed_field",
+            key="worse_computed_field",
             label="Worse Computed Field",
             template="{{ obj.images | list }}",
             fallback_value="Another template error",
@@ -121,15 +121,15 @@ class ComputedFieldTestCase(FilterTestCases.FilterTestCase):
         )
         ComputedField.objects.create(
             content_type=ContentType.objects.get_for_model(Device),
-            slug="device_computed_field",
+            key="device_computed_field",
             label="Device Computed Field",
             template="Hello, world.",
             fallback_value="This template has errored",
             weight=100,
         )
 
-    def test_slug(self):
-        params = {"slug": ["device_computed_field", "worse_computed_field"]}
+    def test_key(self):
+        params = {"key": ["device_computed_field", "worse_computed_field"]}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_content_type(self):
@@ -177,7 +177,7 @@ class ConfigContextTestCase(FilterTestCases.FilterTestCase):
         device_roles = Role.objects.get_for_model(Device)
         cls.device_roles = device_roles
 
-        manufacturer = Manufacturer.objects.create(name="Manufacturer 1", slug="manufacturer-1")
+        manufacturer = Manufacturer.objects.first()
 
         device_types = (
             DeviceType.objects.create(model="Device Type 1", slug="device-type-1", manufacturer=manufacturer),
@@ -186,22 +186,18 @@ class ConfigContextTestCase(FilterTestCases.FilterTestCase):
         )
         cls.device_types = device_types
 
-        platforms = (
-            Platform.objects.create(name="Platform 1", slug="platform-1"),
-            Platform.objects.create(name="Platform 2", slug="platform-2"),
-            Platform.objects.create(name="Platform 3", slug="platform-3"),
-        )
+        platforms = Platform.objects.all()[:3]
         cls.platforms = platforms
 
         cls.locations = Location.objects.all()[:3]
 
         cluster_groups = (
-            ClusterGroup.objects.create(name="Cluster Group 1", slug="cluster-group-1"),
-            ClusterGroup.objects.create(name="Cluster Group 2", slug="cluster-group-2"),
-            ClusterGroup.objects.create(name="Cluster Group 3", slug="cluster-group-3"),
+            ClusterGroup.objects.create(name="Cluster Group 1"),
+            ClusterGroup.objects.create(name="Cluster Group 2"),
+            ClusterGroup.objects.create(name="Cluster Group 3"),
         )
 
-        cluster_type = ClusterType.objects.create(name="Cluster Type 1", slug="cluster-type-1")
+        cluster_type = ClusterType.objects.create(name="Cluster Type 1")
         clusters = (
             Cluster.objects.create(name="Cluster 1", cluster_type=cluster_type),
             Cluster.objects.create(name="Cluster 2", cluster_type=cluster_type),
@@ -252,7 +248,7 @@ class ConfigContextTestCase(FilterTestCases.FilterTestCase):
     def test_role(self):
         device_role = Role.objects.get_for_model(Device).first()
         vm_role = Role.objects.get_for_model(VirtualMachine).first()
-        params = {"role": [device_role.pk, vm_role.slug]}
+        params = {"role": [device_role.pk, vm_role.name]}
         self.assertQuerysetEqualAndNotEmpty(
             self.filterset(params, self.queryset).qs,
             self.queryset.filter(roles__in=[vm_role, device_role]).distinct(),
@@ -273,7 +269,7 @@ class ConfigContextTestCase(FilterTestCases.FilterTestCase):
         platforms = list(self.platforms[:2])
         filter_params = [
             {"platform_id": [platforms[0].pk, platforms[1].pk]},
-            {"platform": [platforms[0].pk, platforms[1].slug]},
+            {"platform": [platforms[0].pk, platforms[1].name]},
         ]
         for params in filter_params:
             self.assertQuerysetEqualAndNotEmpty(
@@ -284,7 +280,7 @@ class ConfigContextTestCase(FilterTestCases.FilterTestCase):
         cluster_groups = list(ClusterGroup.objects.all()[:2])
         filter_params = [
             {"cluster_group_id": [cluster_groups[0].pk, cluster_groups[1].pk]},
-            {"cluster_group": [cluster_groups[0].pk, cluster_groups[1].slug]},
+            {"cluster_group": [cluster_groups[0].pk, cluster_groups[1].name]},
         ]
         for params in filter_params:
             self.assertQuerysetEqualAndNotEmpty(
@@ -301,7 +297,7 @@ class ConfigContextTestCase(FilterTestCases.FilterTestCase):
         tenant_groups = list(self.tenant_groups[:2])
         filter_params = [
             {"tenant_group_id": [tenant_groups[0].pk, tenant_groups[1].pk]},
-            {"tenant_group": [tenant_groups[0].slug, tenant_groups[1].pk]},
+            {"tenant_group": [tenant_groups[0].name, tenant_groups[1].pk]},
         ]
         for params in filter_params:
             self.assertQuerysetEqualAndNotEmpty(
@@ -313,7 +309,7 @@ class ConfigContextTestCase(FilterTestCases.FilterTestCase):
         tenants = list(self.tenants[:2])
         filter_params = [
             {"tenant_id": [tenants[0].pk, tenants[1].pk]},
-            {"tenant": [tenants[0].slug, tenants[1].pk]},
+            {"tenant": [tenants[0].name, tenants[1].pk]},
         ]
         for params in filter_params:
             self.assertQuerysetEqualAndNotEmpty(
@@ -511,8 +507,8 @@ class GitRepositoryTestCase(FilterTestCases.FilterTestCase):
     def setUpTestData(cls):
         # Create Three GitRepository records
         secrets_groups = [
-            SecretsGroup.objects.create(name="Secrets Group 1", slug="secrets-group-1"),
-            SecretsGroup.objects.create(name="Secrets Group 2", slug="secrets-group-2"),
+            SecretsGroup.objects.create(name="Secrets Group 1"),
+            SecretsGroup.objects.create(name="Secrets Group 2"),
         ]
         cls.secrets_groups = secrets_groups
         repos = (
@@ -550,7 +546,7 @@ class GitRepositoryTestCase(FilterTestCases.FilterTestCase):
             ),
         )
         for repo in repos:
-            repo.save(trigger_resync=False)
+            repo.save()
         repos[0].tags.set(Tag.objects.get_for_model(GitRepository))
         repos[1].tags.set(Tag.objects.get_for_model(GitRepository)[:3])
 
@@ -579,7 +575,7 @@ class GitRepositoryTestCase(FilterTestCases.FilterTestCase):
     def test_secrets_group(self):
         filter_params = [
             {"secrets_group_id": [self.secrets_groups[0].pk, self.secrets_groups[1].pk]},
-            {"secrets_group": [self.secrets_groups[0].slug, self.secrets_groups[1].pk]},
+            {"secrets_group": [self.secrets_groups[0].name, self.secrets_groups[1].pk]},
         ]
         for params in filter_params:
             self.assertQuerysetEqualAndNotEmpty(
@@ -588,7 +584,7 @@ class GitRepositoryTestCase(FilterTestCases.FilterTestCase):
             )
 
 
-class GraphQLTestCase(FilterTestCases.NameSlugFilterTestCase):
+class GraphQLTestCase(FilterTestCases.NameOnlyFilterTestCase):
     queryset = GraphQLQuery.objects.all()
     filterset = GraphQLQueryFilterSet
 
@@ -597,17 +593,14 @@ class GraphQLTestCase(FilterTestCases.NameSlugFilterTestCase):
         graphqlqueries = (
             GraphQLQuery(
                 name="graphql-query-1",
-                slug="graphql-query-1",
                 query="{ query: locations {name} }",
             ),
             GraphQLQuery(
                 name="graphql-query-2",
-                slug="graphql-query-2",
                 query='{ devices(role: "edge") { id, name, device_role { name slug } } }',
             ),
             GraphQLQuery(
                 name="graphql-query-3",
-                slug="graphql-query-3",
                 query="""
 query ($device: String!) {
   devices(name: $device) {
@@ -720,9 +713,10 @@ class ImageAttachmentTestCase(FilterTestCases.FilterTestCase):
 
         locations = Location.objects.filter(location_type=LocationType.objects.get(name="Campus"))[:2]
 
+        rack_status = Status.objects.get_for_model(Rack).first()
         racks = (
-            Rack.objects.create(name="Rack 1", location=locations[0]),
-            Rack.objects.create(name="Rack 2", location=locations[1]),
+            Rack.objects.create(name="Rack 1", location=locations[0], status=rack_status),
+            Rack.objects.create(name="Rack 2", location=locations[1], status=rack_status),
         )
 
         ImageAttachment.objects.create(
@@ -774,7 +768,7 @@ class ImageAttachmentTestCase(FilterTestCases.FilterTestCase):
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
 
 
-class JobFilterSetTestCase(FilterTestCases.NameSlugFilterTestCase):
+class JobFilterSetTestCase(FilterTestCases.NameOnlyFilterTestCase):
     queryset = Job.objects.all()
     filterset = JobFilterSet
 
@@ -784,7 +778,7 @@ class JobFilterSetTestCase(FilterTestCases.NameSlugFilterTestCase):
         Job.objects.last().tags.set(Tag.objects.get_for_model(Job)[:3])
 
     def test_grouping(self):
-        params = {"grouping": ["test_file_upload_pass", "test_file_upload_fail"]}
+        params = {"grouping": ["file_upload_pass", "file_upload_fail"]}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_installed(self):
@@ -795,8 +789,8 @@ class JobFilterSetTestCase(FilterTestCases.NameSlugFilterTestCase):
         params = {"job_class_name": "TestPass", "enabled": False}
         self.assertTrue(self.filterset(params, self.queryset).qs.exists())
 
-    def test_commit_default(self):
-        params = {"commit_default": False}
+    def test_dryrun_default(self):
+        params = {"dryrun_default": True}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 0)
 
     def test_hidden(self):
@@ -805,15 +799,27 @@ class JobFilterSetTestCase(FilterTestCases.NameSlugFilterTestCase):
 
     def test_read_only(self):
         params = {"read_only": True}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs, self.queryset.filter(read_only=True)
+        )
 
     def test_approval_required(self):
         params = {"approval_required": True}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 0)
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(approval_required=True),
+        )
 
     def test_search(self):
         params = {"q": "file"}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
+        expected_matches = (
+            Q(name__icontains="file")  # pylint: disable=unsupported-binary-operation
+            | Q(grouping__icontains="file")
+            | Q(description__icontains="file")
+        )
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs, self.queryset.filter(expected_matches)
+        )
         value = self.queryset.values_list("pk", flat=True)[0]
         params = {"q": value}
         self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
@@ -836,16 +842,14 @@ class JobResultFilterSetTestCase(FilterTestCases.FilterTestCase):
                 job_model=job,
                 name=job.class_path,
                 user=User.objects.first(),
-                obj_type=ContentType.objects.get_for_model(Job),
                 status=JobResultStatusChoices.STATUS_STARTED,
-                task_id=job.pk,
             )
 
     def test_job_model(self):
         jobs = list(self.jobs[:2])
         filter_params = [
             {"job_model_id": [jobs[0].pk, jobs[1].pk]},
-            {"job_model": [jobs[0].pk, jobs[1].slug]},
+            {"job_model": [jobs[0].pk, jobs[1].name]},
         ]
         for params in filter_params:
             self.assertQuerysetEqualAndNotEmpty(
@@ -853,7 +857,7 @@ class JobResultFilterSetTestCase(FilterTestCases.FilterTestCase):
             )
 
 
-class JobHookFilterSetTestCase(FilterTestCases.NameSlugFilterTestCase):
+class JobHookFilterSetTestCase(FilterTestCases.NameOnlyFilterTestCase):
     queryset = JobHook.objects.all()
     filterset = JobHookFilterSet
 
@@ -900,11 +904,7 @@ class JobHookFilterSetTestCase(FilterTestCases.NameSlugFilterTestCase):
 
     def test_job(self):
         jobs = Job.objects.filter(job_class_name__in=["TestJobHookReceiverLog", "TestJobHookReceiverChange"])[:2]
-        params = {"job": [jobs[0].slug, jobs[1].pk]}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
-
-    def test_slug(self):
-        params = {"slug": ["jobhook1", "jobhook2"]}
+        params = {"job": [jobs[0].name, jobs[1].pk]}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_type_create(self):
@@ -973,9 +973,9 @@ class JobButtonFilterTestCase(FilterTestCases.FilterTestCase):
             self.filterset(params, self.queryset).qs, self.queryset.filter(job__pk=job.pk)
         )
 
-        params = {"job": [job.slug]}
+        params = {"job": [job.name]}
         self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs, self.queryset.filter(job__slug=job.slug)
+            self.filterset(params, self.queryset).qs, self.queryset.filter(job__name=job.name)
         )
 
     def test_weight(self):
@@ -998,13 +998,9 @@ class JobLogEntryTestCase(FilterTestCases.FilterTestCase):
 
     @classmethod
     def setUpTestData(cls):
-        cls.job_result = JobResult.objects.create(
-            name="test",
-            task_id=uuid.uuid4(),
-            obj_type=ContentType.objects.get_for_model(GitRepository),
-        )
+        cls.job_result = JobResult.objects.create(name="test")
 
-        for log_level in ("debug", "info", "success", "warning"):
+        for log_level in ("debug", "info", "warning", "error", "critical"):
             JobLogEntry.objects.create(
                 log_level=log_level,
                 grouping="run",
@@ -1013,24 +1009,36 @@ class JobLogEntryTestCase(FilterTestCases.FilterTestCase):
             )
 
     def test_log_level(self):
-        params = {"log_level": ["success"]}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"log_level": ["debug"]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs, self.queryset.filter(log_level="debug")
+        )
 
     def test_grouping(self):
         params = {"grouping": ["run"]}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs, self.queryset.filter(grouping="run")
+        )
 
     def test_message(self):
-        params = {"message": ["I am a success log."]}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"message": ["I am a debug log."]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs, self.queryset.filter(message="I am a debug log.")
+        )
 
     def test_search(self):
         params = {"q": "run"}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs, self.queryset.filter(grouping__icontains="run")
+        )
         params = {"q": "warning log"}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
-        params = {"q": "success"}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs, self.queryset.filter(message__icontains="warning log")
+        )
+        params = {"q": "debug"}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs, self.queryset.filter(log_level__icontains="debug")
+        )
 
 
 class ObjectChangeTestCase(FilterTestCases.FilterTestCase):
@@ -1046,7 +1054,11 @@ class ObjectChangeTestCase(FilterTestCases.FilterTestCase):
         )
 
         location = Location.objects.first()
-        ipaddress = IPAddress.objects.create(address="192.0.2.1/24")
+        ipaddr_status = Status.objects.get_for_model(IPAddress).first()
+        prefix_status = Status.objects.get_for_model(Prefix).first()
+        namespace = Namespace.objects.first()
+        Prefix.objects.create(prefix="192.0.2.0/24", namespace=namespace, status=prefix_status)
+        ipaddress = IPAddress.objects.create(address="192.0.2.1/24", namespace=namespace, status=ipaddr_status)
 
         ObjectChange.objects.create(
             user=users[0],
@@ -1082,7 +1094,7 @@ class ObjectChangeTestCase(FilterTestCases.FilterTestCase):
             action=ObjectChangeActionChoices.ACTION_CREATE,
             changed_object=ipaddress,
             object_repr=str(ipaddress),
-            object_data={"address": str(ipaddress.address), "status": ipaddress.status},
+            object_data={"address": str(ipaddress.address), "status": str(ipaddress.status)},
         )
         ObjectChange.objects.create(
             user=users[2],
@@ -1091,7 +1103,7 @@ class ObjectChangeTestCase(FilterTestCases.FilterTestCase):
             action=ObjectChangeActionChoices.ACTION_UPDATE,
             changed_object=ipaddress,
             object_repr=str(ipaddress),
-            object_data={"address": str(ipaddress.address), "status": ipaddress.status},
+            object_data={"address": str(ipaddress.address), "status": str(ipaddress.status)},
         )
         ObjectChange.objects.create(
             user=users[2],
@@ -1100,7 +1112,7 @@ class ObjectChangeTestCase(FilterTestCases.FilterTestCase):
             action=ObjectChangeActionChoices.ACTION_DELETE,
             changed_object=ipaddress,
             object_repr=str(ipaddress),
-            object_data={"address": str(ipaddress.address), "status": ipaddress.status},
+            object_data={"address": str(ipaddress.address), "status": str(ipaddress.status)},
         )
 
     def test_user(self):
@@ -1132,7 +1144,7 @@ class ObjectChangeTestCase(FilterTestCases.FilterTestCase):
         self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
 
 
-class RelationshipTestCase(FilterTestCases.NameSlugFilterTestCase):
+class RelationshipTestCase(FilterTestCases.FilterTestCase):
     queryset = Relationship.objects.all()
     filterset = RelationshipFilterSet
 
@@ -1143,27 +1155,43 @@ class RelationshipTestCase(FilterTestCases.NameSlugFilterTestCase):
         vlan_type = ContentType.objects.get_for_model(VLAN)
 
         Relationship(
-            name="Device VLANs",
-            slug="device-vlans",
+            label="Device VLANs",
+            key="device_vlans",
             type="many-to-many",
             source_type=device_type,
             destination_type=vlan_type,
         ).validated_save()
         Relationship(
-            name="Primary VLAN",
-            slug="primary-vlan",
+            label="Primary VLAN",
+            key="primary_vlan",
             type="one-to-many",
             source_type=vlan_type,
             destination_type=device_type,
         ).validated_save()
         Relationship(
-            name="Primary Interface",
-            slug="primary-interface",
+            label="Primary Interface",
+            key="primary_interface",
             type="one-to-one",
             source_type=device_type,
             destination_type=interface_type,
         ).validated_save()
 
+    def test_label(self):
+        """Verify that the filterset supports filtering by label."""
+        params = {"label": list(self.queryset.values_list("label", flat=True)[:2])}
+        filterset = self.filterset(params, self.queryset)
+        self.assertTrue(filterset.is_valid())
+        self.assertQuerysetEqualAndNotEmpty(
+            filterset.qs.order_by("label"), self.queryset.filter(label__in=params["label"]).order_by("label")
+        )
+
+    def test_key(self):
+        """Verify that the filterset supports filtering by key."""
+        params = {"key": self.queryset.values_list("key", flat=True)[:2]}
+        filterset = self.filterset(params, self.queryset)
+        self.assertTrue(filterset.is_valid())
+        self.assertEqual(filterset.qs.count(), 2)
+
     def test_type(self):
         params = {"type": ["one-to-many"]}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
@@ -1188,22 +1216,22 @@ class RelationshipAssociationTestCase(FilterTestCases.FilterTestCase):
 
         cls.relationships = (
             Relationship(
-                name="Device VLANs",
-                slug="device-vlans",
+                label="Device VLANs",
+                key="device_vlans",
                 type="many-to-many",
                 source_type=cls.device_type,
                 destination_type=cls.vlan_type,
             ),
             Relationship(
-                name="Primary VLAN",
-                slug="primary-vlan",
+                label="Primary VLAN",
+                key="primary_vlan",
                 type="one-to-many",
                 source_type=cls.vlan_type,
                 destination_type=cls.device_type,
             ),
             Relationship(
-                name="Device Device",
-                slug="symmetric-device-device",
+                label="Device Device",
+                key="symmetric_device_device",
                 type="symmetric-many-to-many",
                 source_type=cls.device_type,
                 destination_type=cls.device_type,
@@ -1212,18 +1240,26 @@ class RelationshipAssociationTestCase(FilterTestCases.FilterTestCase):
         for relationship in cls.relationships:
             relationship.validated_save()
 
-        manufacturer = Manufacturer.objects.create(name="Manufacturer 1", slug="manufacturer-1")
+        manufacturer = Manufacturer.objects.first()
         devicetype = DeviceType.objects.create(manufacturer=manufacturer, model="Device Type 1", slug="device-type-1")
         devicerole = Role.objects.get_for_model(Device).first()
+        devicestatus = Status.objects.get_for_model(Device).first()
         location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
         cls.devices = (
-            Device.objects.create(name="Device 1", device_type=devicetype, role=devicerole, location=location),
-            Device.objects.create(name="Device 2", device_type=devicetype, role=devicerole, location=location),
-            Device.objects.create(name="Device 3", device_type=devicetype, role=devicerole, location=location),
+            Device.objects.create(
+                name="Device 1", device_type=devicetype, role=devicerole, status=devicestatus, location=location
+            ),
+            Device.objects.create(
+                name="Device 2", device_type=devicetype, role=devicerole, status=devicestatus, location=location
+            ),
+            Device.objects.create(
+                name="Device 3", device_type=devicetype, role=devicerole, status=devicestatus, location=location
+            ),
         )
+        vlan_status = Status.objects.get_for_model(VLAN).first()
         cls.vlans = (
-            VLAN.objects.create(vid=1, name="VLAN 1"),
-            VLAN.objects.create(vid=2, name="VLAN 2"),
+            VLAN.objects.create(vid=1, name="VLAN 1", status=vlan_status),
+            VLAN.objects.create(vid=2, name="VLAN 2", status=vlan_status),
         )
 
         RelationshipAssociation(
@@ -1270,7 +1306,7 @@ class RelationshipAssociationTestCase(FilterTestCases.FilterTestCase):
         ).validated_save()
 
     def test_relationship(self):
-        params = {"relationship": [self.relationships[0].slug]}
+        params = {"relationship": [self.relationships[0].key]}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_source_type(self):
@@ -1306,22 +1342,22 @@ class RelationshipModelFilterSetTestCase(FilterTestCases.FilterTestCase):
         cls.vlan_type = ContentType.objects.get_for_model(VLAN)
         cls.relationships = (
             Relationship(
-                name="Device VLANs",
-                slug="device-vlans",
+                label="Device VLANs",
+                key="device_vlans",
                 type="many-to-many",
                 source_type=cls.device_type,
                 destination_type=cls.vlan_type,
             ),
             Relationship(
-                name="Primary VLAN",
-                slug="primary-vlan",
+                label="Primary VLAN",
+                key="primary_vlan",
                 type="one-to-many",
                 source_type=cls.vlan_type,
                 destination_type=cls.device_type,
             ),
             Relationship(
-                name="Device Peers",
-                slug="device-peers",
+                label="Device Peers",
+                key="device_peers",
                 type="symmetric-many-to-many",
                 source_type=cls.device_type,
                 destination_type=cls.device_type,
@@ -1330,19 +1366,27 @@ class RelationshipModelFilterSetTestCase(FilterTestCases.FilterTestCase):
         for relationship in cls.relationships:
             relationship.validated_save()
 
-        manufacturer = Manufacturer.objects.create(name="Manufacturer 1", slug="manufacturer-1")
+        manufacturer = Manufacturer.objects.first()
         devicetype = DeviceType.objects.create(manufacturer=manufacturer, model="Device Type 1", slug="device-type-1")
         devicerole = Role.objects.get_for_model(Device).first()
+        devicestatus = Status.objects.get_for_model(Device).first()
         location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
         cls.devices = (
-            Device.objects.create(name="Device 1", device_type=devicetype, role=devicerole, location=location),
-            Device.objects.create(name="Device 2", device_type=devicetype, role=devicerole, location=location),
-            Device.objects.create(name="Device 3", device_type=devicetype, role=devicerole, location=location),
+            Device.objects.create(
+                name="Device 1", device_type=devicetype, role=devicerole, status=devicestatus, location=location
+            ),
+            Device.objects.create(
+                name="Device 2", device_type=devicetype, role=devicerole, status=devicestatus, location=location
+            ),
+            Device.objects.create(
+                name="Device 3", device_type=devicetype, role=devicerole, status=devicestatus, location=location
+            ),
         )
+        vlan_status = Status.objects.get_for_model(VLAN).first()
         cls.vlans = (
-            VLAN.objects.create(vid=1, name="VLAN 1"),
-            VLAN.objects.create(vid=2, name="VLAN 2"),
-            VLAN.objects.create(vid=3, name="VLAN 3"),
+            VLAN.objects.create(vid=1, name="VLAN 1", status=vlan_status),
+            VLAN.objects.create(vid=2, name="VLAN 2", status=vlan_status),
+            VLAN.objects.create(vid=3, name="VLAN 3", status=vlan_status),
         )
         cls.relationship_associations = (
             RelationshipAssociation(
@@ -1409,7 +1453,7 @@ class RelationshipModelFilterSetTestCase(FilterTestCases.FilterTestCase):
         self.queryset = Device.objects.all()
         self.filterset = DeviceFilterSet
         self.assertEqual(
-            self.filterset({f"cr_{self.relationships[1].slug}__source": [self.vlans[0].pk]}, self.queryset).qs.count(),
+            self.filterset({f"cr_{self.relationships[1].key}__source": [self.vlans[0].pk]}, self.queryset).qs.count(),
             3,
         )
 
@@ -1418,7 +1462,7 @@ class RelationshipModelFilterSetTestCase(FilterTestCases.FilterTestCase):
         self.filterset = VLANFilterSet
         self.assertEqual(
             self.filterset(
-                {f"cr_{self.relationships[1].slug}__destination": [self.devices[0].pk, self.devices[1].pk]},
+                {f"cr_{self.relationships[1].key}__destination": [self.devices[0].pk, self.devices[1].pk]},
                 self.queryset,
             ).qs.count(),
             1,
@@ -1429,7 +1473,7 @@ class RelationshipModelFilterSetTestCase(FilterTestCases.FilterTestCase):
         self.filterset = VLANFilterSet
         self.assertEqual(
             self.filterset(
-                {f"cr_{self.relationships[0].slug}__source": [self.devices[0].pk, self.devices[1].pk]}, self.queryset
+                {f"cr_{self.relationships[0].key}__source": [self.devices[0].pk, self.devices[1].pk]}, self.queryset
             ).qs.count(),
             2,
         )
@@ -1439,7 +1483,7 @@ class RelationshipModelFilterSetTestCase(FilterTestCases.FilterTestCase):
         self.filterset = DeviceFilterSet
         self.assertEqual(
             self.filterset(
-                {f"cr_{self.relationships[0].slug}__destination": [self.vlans[0].pk, self.vlans[1].pk]}, self.queryset
+                {f"cr_{self.relationships[0].key}__destination": [self.vlans[0].pk, self.vlans[1].pk]}, self.queryset
             ).qs.count(),
             2,
         )
@@ -1449,12 +1493,12 @@ class RelationshipModelFilterSetTestCase(FilterTestCases.FilterTestCase):
         self.filterset = DeviceFilterSet
         self.assertEqual(
             self.filterset(
-                {f"cr_{self.relationships[2].slug}__peer": [self.devices[0].pk, self.devices[1].pk]}, self.queryset
+                {f"cr_{self.relationships[2].key}__peer": [self.devices[0].pk, self.devices[1].pk]}, self.queryset
             ).qs.count(),
             3,
         )
         self.assertEqual(
-            self.filterset({f"cr_{self.relationships[2].slug}__peer": [self.devices[2].pk]}, self.queryset).qs.count(),
+            self.filterset({f"cr_{self.relationships[2].key}__peer": [self.devices[2].pk]}, self.queryset).qs.count(),
             2,
         )
 
@@ -1464,8 +1508,8 @@ class RelationshipModelFilterSetTestCase(FilterTestCases.FilterTestCase):
         self.assertEqual(
             self.filterset(
                 {
-                    f"cr_{self.relationships[2].slug}__peer": [self.devices[0].pk, self.devices[1].pk],
-                    f"cr_{self.relationships[0].slug}__destination": [self.vlans[0].pk, self.vlans[1].pk],
+                    f"cr_{self.relationships[2].key}__peer": [self.devices[0].pk, self.devices[1].pk],
+                    f"cr_{self.relationships[0].key}__destination": [self.vlans[0].pk, self.vlans[1].pk],
                 },
                 self.queryset,
             ).qs.count(),
@@ -1474,8 +1518,8 @@ class RelationshipModelFilterSetTestCase(FilterTestCases.FilterTestCase):
         self.assertEqual(
             self.filterset(
                 {
-                    f"cr_{self.relationships[2].slug}__peer": [self.devices[2].pk],
-                    f"cr_{self.relationships[0].slug}__destination": [self.vlans[0].pk, self.vlans[1].pk],
+                    f"cr_{self.relationships[2].key}__peer": [self.devices[2].pk],
+                    f"cr_{self.relationships[0].key}__destination": [self.vlans[0].pk, self.vlans[1].pk],
                 },
                 self.queryset,
             ).qs.count(),
@@ -1494,7 +1538,7 @@ class RelationshipModelFilterSetTestCase(FilterTestCases.FilterTestCase):
         self.assertEqual(
             self.filterset(
                 {
-                    f"cr_{self.relationships[0].slug}__destination": [self.vlans[0].pk, self.vlans[1].pk],
+                    f"cr_{self.relationships[0].key}__destination": [self.vlans[0].pk, self.vlans[1].pk],
                     "manufacturer": ["manufacturer-1"],
                 },
                 self.queryset,
@@ -1503,7 +1547,7 @@ class RelationshipModelFilterSetTestCase(FilterTestCases.FilterTestCase):
         )
 
 
-class SecretTestCase(FilterTestCases.NameSlugFilterTestCase):
+class SecretTestCase(FilterTestCases.NameOnlyFilterTestCase):
     queryset = Secret.objects.all()
     filterset = SecretFilterSet
 
@@ -1526,7 +1570,6 @@ class SecretTestCase(FilterTestCases.NameSlugFilterTestCase):
                 parameters={"path": "/github-tokens/user/myusername.txt"},
             ),
         )
-
         for secret in secrets:
             secret.validated_save()
         secrets[0].tags.set(Tag.objects.get_for_model(Secret))
@@ -1542,15 +1585,15 @@ class SecretTestCase(FilterTestCases.NameSlugFilterTestCase):
         self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
 
 
-class SecretsGroupTestCase(FilterTestCases.NameSlugFilterTestCase):
+class SecretsGroupTestCase(FilterTestCases.NameOnlyFilterTestCase):
     queryset = SecretsGroup.objects.all()
     filterset = SecretsGroupFilterSet
 
     @classmethod
     def setUpTestData(cls):
-        SecretsGroup.objects.create(name="Group 1", slug="group-1")
-        SecretsGroup.objects.create(name="Group 2", slug="group-2")
-        SecretsGroup.objects.create(name="Group 3", slug="group-3")
+        SecretsGroup.objects.create(name="Group 1")
+        SecretsGroup.objects.create(name="Group 2")
+        SecretsGroup.objects.create(name="Group 3")
 
     def test_search(self):
         value = self.queryset.values_list("pk", flat=True)[0]
@@ -1562,10 +1605,7 @@ class SecretsGroupAssociationTestCase(FilterTestCases.FilterTestCase):
     queryset = SecretsGroupAssociation.objects.all()
     filterset = SecretsGroupAssociationFilterSet
 
-    generic_filter_tests = (
-        ["secrets_group", "secrets_group__id"],
-        ["secrets_group", "secrets_group__slug"],
-    )
+    generic_filter_tests = (["secrets_group", "secrets_group__id"],)
 
     @classmethod
     def setUpTestData(cls):
@@ -1591,9 +1631,9 @@ class SecretsGroupAssociationTestCase(FilterTestCases.FilterTestCase):
             secret.validated_save()
 
         cls.groups = (
-            SecretsGroup.objects.create(name="Group 1", slug="group-1"),
-            SecretsGroup.objects.create(name="Group 2", slug="group-2"),
-            SecretsGroup.objects.create(name="Group 3", slug="group-3"),
+            SecretsGroup.objects.create(name="Group 1"),
+            SecretsGroup.objects.create(name="Group 2"),
+            SecretsGroup.objects.create(name="Group 3"),
         )
 
         SecretsGroupAssociation.objects.create(
@@ -1618,7 +1658,7 @@ class SecretsGroupAssociationTestCase(FilterTestCases.FilterTestCase):
     def test_secret(self):
         filter_params = [
             {"secret_id": [self.secrets[0].pk, self.secrets[1].pk]},
-            {"secret": [self.secrets[0].slug, self.secrets[1].pk]},
+            {"secret": [self.secrets[0].name, self.secrets[1].pk]},
         ]
         for params in filter_params:
             self.assertQuerysetEqualAndNotEmpty(
@@ -1634,7 +1674,7 @@ class SecretsGroupAssociationTestCase(FilterTestCases.FilterTestCase):
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
 
-class StatusTestCase(FilterTestCases.NameSlugFilterTestCase):
+class StatusTestCase(FilterTestCases.NameOnlyFilterTestCase):
     queryset = Status.objects.all()
     filterset = StatusFilterSet
 
@@ -1655,7 +1695,7 @@ class StatusTestCase(FilterTestCases.NameSlugFilterTestCase):
         params = {"q": "active"}
         # TODO: Remove pylint disable after issue is resolved (see: https://github.com/PyCQA/pylint/issues/7381)
         # pylint: disable=unsupported-binary-operation
-        q = Q(id__iexact="active") | Q(name__icontains="active") | Q(slug__icontains="active")
+        q = Q(id__iexact="active") | Q(name__icontains="active")
         # pylint: enable=unsupported-binary-operation
         q |= Q(content_types__model__icontains="active")
         self.assertQuerysetEqualAndNotEmpty(
@@ -1758,7 +1798,7 @@ class WebhookTestCase(FilterTestCases.FilterTestCase):
         self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
 
 
-class RoleTestCase(FilterTestCases.NameSlugFilterTestCase):
+class RoleTestCase(FilterTestCases.NameOnlyFilterTestCase):
     queryset = Role.objects.all()
     filterset = RoleFilterSet