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

nautobot/extras/tests/test_filters.py

@@ -1,5 +1,4 @@
 import uuid
-from unittest import skip
 
 from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
@@ -88,7 +87,6 @@ from nautobot.virtualization.models import Cluster, ClusterGroup, ClusterType, V
 User = get_user_model()
 
 
-@skip(reason="Content Types are BROKEN")
 class ComputedFieldTestCase(FilterTestCases.FilterTestCase):
     queryset = ComputedField.objects.all()
     filterset = ComputedFieldFilterSet
@@ -97,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.",
@@ -106,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",
@@ -115,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",
@@ -123,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):
@@ -548,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])
 
@@ -715,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(
@@ -769,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
 
@@ -779,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):
@@ -790,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):
@@ -800,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)
@@ -831,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(
@@ -895,7 +904,7 @@ class JobHookFilterSetTestCase(FilterTestCases.NameOnlyFilterTestCase):
 
     def test_job(self):
         jobs = Job.objects.filter(job_class_name__in=["TestJobHookReceiverLog", "TestJobHookReceiverChange"])[:2]
-        params = {"job": [jobs[0].slug, jobs[1].pk]}
+        params = {"job": [jobs[0].name, jobs[1].pk]}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_type_create(self):
@@ -964,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):
@@ -989,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",
@@ -1004,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):
@@ -1037,9 +1054,11 @@ class ObjectChangeTestCase(FilterTestCases.FilterTestCase):
         )
 
         location = Location.objects.first()
+        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)
-        ipaddress = IPAddress.objects.create(address="192.0.2.1/24", namespace=namespace)
+        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],
@@ -1075,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],
@@ -1084,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],
@@ -1093,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):
@@ -1125,8 +1144,7 @@ class ObjectChangeTestCase(FilterTestCases.FilterTestCase):
         self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
 
 
-@skip(reason="Content Types are BROKEN")
-class RelationshipTestCase(FilterTestCases.NameSlugFilterTestCase):
+class RelationshipTestCase(FilterTestCases.FilterTestCase):
     queryset = Relationship.objects.all()
     filterset = RelationshipFilterSet
 
@@ -1137,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)
@@ -1171,7 +1205,6 @@ class RelationshipTestCase(FilterTestCases.NameSlugFilterTestCase):
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
 
-@skip(reason="Content Types are BROKEN")
 class RelationshipAssociationTestCase(FilterTestCases.FilterTestCase):
     queryset = RelationshipAssociation.objects.all()
     filterset = RelationshipAssociationFilterSet
@@ -1183,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,
@@ -1210,15 +1243,23 @@ class RelationshipAssociationTestCase(FilterTestCases.FilterTestCase):
         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(
@@ -1265,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):
@@ -1291,7 +1332,6 @@ class RelationshipAssociationTestCase(FilterTestCases.FilterTestCase):
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
 
 
-@skip(reason="Content Types are BROKEN")
 class RelationshipModelFilterSetTestCase(FilterTestCases.FilterTestCase):
     queryset = RelationshipAssociation.objects.all()
     filterset = RelationshipAssociationFilterSet
@@ -1302,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,
@@ -1329,16 +1369,24 @@ class RelationshipModelFilterSetTestCase(FilterTestCases.FilterTestCase):
         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(
@@ -1405,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,
         )
 
@@ -1414,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,
@@ -1425,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,
         )
@@ -1435,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,
         )
@@ -1445,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,
         )
 
@@ -1460,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(),
@@ -1470,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(),
@@ -1490,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,