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

nautobot/extras/tests/test_relationships.py

@@ -1,5 +1,6 @@
 import logging
 import uuid
+from unittest import skip
 
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
@@ -23,134 +24,137 @@ from nautobot.extras.models import Relationship, RelationshipAssociation, Status
 
 
 class RelationshipBaseTest(TestCase):
-    def setUp(self):
-
-        self.location_ct = ContentType.objects.get_for_model(Location)
-        self.rack_ct = ContentType.objects.get_for_model(Rack)
-        self.vlan_ct = ContentType.objects.get_for_model(VLAN)
-
-        self.locations = Location.objects.all()[:5]
-
-        self.racks = [
-            Rack.objects.create(name="Rack A", location=self.locations[0]),
-            Rack.objects.create(name="Rack B", location=self.locations[1]),
-            Rack.objects.create(name="Rack C", location=self.locations[2]),
+    @classmethod
+    def setUpTestData(cls):
+        cls.location_ct = ContentType.objects.get_for_model(Location)
+        cls.rack_ct = ContentType.objects.get_for_model(Rack)
+        cls.vlan_ct = ContentType.objects.get_for_model(VLAN)
+
+        cls.locations = Location.objects.all()[:5]
+
+        cls.rack_status = Status.objects.get_for_model(Rack).first()
+        cls.racks = [
+            Rack.objects.create(name="Rack A", location=cls.locations[0], status=cls.rack_status),
+            Rack.objects.create(name="Rack B", location=cls.locations[1], status=cls.rack_status),
+            Rack.objects.create(name="Rack C", location=cls.locations[2], status=cls.rack_status),
         ]
 
-        self.vlans = [
-            VLAN.objects.create(name="VLAN A", vid=100, location=self.locations[0]),
-            VLAN.objects.create(name="VLAN B", vid=100, location=self.locations[1]),
-            VLAN.objects.create(name="VLAN C", vid=100, location=self.locations[2]),
+        cls.vlan_status = Status.objects.get_for_model(VLAN).first()
+        cls.vlans = [
+            VLAN.objects.create(name="VLAN A", vid=100, location=cls.locations[0], status=cls.vlan_status),
+            VLAN.objects.create(name="VLAN B", vid=100, location=cls.locations[1], status=cls.vlan_status),
+            VLAN.objects.create(name="VLAN C", vid=100, location=cls.locations[2], status=cls.vlan_status),
         ]
 
-        self.m2m_1 = Relationship(
-            name="Vlan to Rack",
-            slug="vlan-rack",
-            source_type=self.rack_ct,
+        cls.m2m_1 = Relationship(
+            label="Vlan to Rack",
+            key="vlan_rack",
+            source_type=cls.rack_ct,
             source_label="My Vlans",
-            source_filter={"location": [self.locations[0].slug, self.locations[1].slug, self.locations[2].slug]},
-            destination_type=self.vlan_ct,
+            source_filter={"location": [cls.locations[0].slug, cls.locations[1].slug, cls.locations[2].slug]},
+            destination_type=cls.vlan_ct,
             destination_label="My Racks",
             type=RelationshipTypeChoices.TYPE_MANY_TO_MANY,
         )
-        self.m2m_1.validated_save()
+        cls.m2m_1.validated_save()
 
-        self.m2m_2 = Relationship(
-            name="Another Vlan to Rack",
-            slug="vlan-rack-2",
-            source_type=self.rack_ct,
-            destination_type=self.vlan_ct,
+        cls.m2m_2 = Relationship(
+            label="Another Vlan to Rack",
+            key="vlan_rack_2",
+            source_type=cls.rack_ct,
+            destination_type=cls.vlan_ct,
             type=RelationshipTypeChoices.TYPE_MANY_TO_MANY,
         )
-        self.m2m_2.validated_save()
+        cls.m2m_2.validated_save()
 
-        self.o2m_1 = Relationship(
-            name="generic location to vlan",
-            slug="location-vlan",
-            source_type=self.location_ct,
-            destination_type=self.vlan_ct,
+        cls.o2m_1 = Relationship(
+            label="generic location to vlan",
+            key="location_vlan",
+            source_type=cls.location_ct,
+            destination_type=cls.vlan_ct,
             type=RelationshipTypeChoices.TYPE_ONE_TO_MANY,
         )
-        self.o2m_1.validated_save()
+        cls.o2m_1.validated_save()
 
-        self.o2o_1 = Relationship(
-            name="Primary Rack per Location",
-            slug="primary-rack-location",
-            source_type=self.rack_ct,
+        cls.o2o_1 = Relationship(
+            label="Primary Rack per Location",
+            key="primary_rack_location",
+            source_type=cls.rack_ct,
             source_hidden=True,
-            destination_type=self.location_ct,
+            destination_type=cls.location_ct,
             destination_label="Primary Rack",
             type=RelationshipTypeChoices.TYPE_ONE_TO_ONE,
         )
-        self.o2o_1.validated_save()
+        cls.o2o_1.validated_save()
 
         # Relationships between objects of the same type
 
-        self.o2o_2 = Relationship(
-            name="Alphabetical Locations",
-            slug="alphabetical-locations",
-            source_type=self.location_ct,
+        cls.o2o_2 = Relationship(
+            label="Alphabetical Locations",
+            key="alphabetical_locations",
+            source_type=cls.location_ct,
             source_label="Alphabetically Prior",
-            destination_type=self.location_ct,
+            destination_type=cls.location_ct,
             destination_label="Alphabetically Subsequent",
             type=RelationshipTypeChoices.TYPE_ONE_TO_ONE,
         )
-        self.o2o_2.validated_save()
+        cls.o2o_2.validated_save()
 
-        self.o2os_1 = Relationship(
-            name="Redundant Rack",
-            slug="redundant-rack",
-            source_type=self.rack_ct,
-            destination_type=self.rack_ct,
+        cls.o2os_1 = Relationship(
+            label="Redundant Rack",
+            key="redundant_rack",
+            source_type=cls.rack_ct,
+            destination_type=cls.rack_ct,
             type=RelationshipTypeChoices.TYPE_ONE_TO_ONE_SYMMETRIC,
         )
-        self.o2os_1.validated_save()
+        cls.o2os_1.validated_save()
 
-        self.m2ms_1 = Relationship(
-            name="Related Locations",
-            slug="related-locations",
-            source_type=self.location_ct,
-            destination_type=self.location_ct,
+        cls.m2ms_1 = Relationship(
+            label="Related Locations",
+            key="related_locations",
+            source_type=cls.location_ct,
+            destination_type=cls.location_ct,
             type=RelationshipTypeChoices.TYPE_MANY_TO_MANY_SYMMETRIC,
         )
-        self.m2ms_1.validated_save()
+        cls.m2ms_1.validated_save()
 
         # Relationships involving a content type that doesn't actually have a backing model.
         # This can occur in practice if, for example, a relationship is defined for a plugin-defined model,
         # then the plugin is subsequently uninstalled or deactivated.
-        self.invalid_ct = ContentType.objects.create(app_label="nonexistent", model="nosuchmodel")
+        cls.invalid_ct = ContentType.objects.create(app_label="nonexistent", model="nosuchmodel")
 
         # Don't use validated_save() on these as it will fail due to the invalid content-type
-        self.invalid_relationships = [
+        cls.invalid_relationships = [
             Relationship.objects.create(
-                name="Invalid Relationship 1",
-                slug="invalid-relationship-1",
-                source_type=self.location_ct,
-                destination_type=self.invalid_ct,
+                label="Invalid Relationship 1",
+                key="invalid_relationship_1",
+                source_type=cls.location_ct,
+                destination_type=cls.invalid_ct,
                 type=RelationshipTypeChoices.TYPE_ONE_TO_ONE,
             ),
             Relationship.objects.create(
-                name="Invalid Relationship 2",
-                slug="invalid-relationship-2",
-                source_type=self.invalid_ct,
-                destination_type=self.location_ct,
+                label="Invalid Relationship 2",
+                key="invalid_relationship_2",
+                source_type=cls.invalid_ct,
+                destination_type=cls.location_ct,
                 type=RelationshipTypeChoices.TYPE_ONE_TO_MANY,
             ),
             Relationship.objects.create(
-                name="Invalid Relationship 3",
-                slug="invalid-relationship-3",
-                source_type=self.invalid_ct,
-                destination_type=self.invalid_ct,
+                label="Invalid Relationship 3",
+                key="invalid_relationship_3",
+                source_type=cls.invalid_ct,
+                destination_type=cls.invalid_ct,
                 type=RelationshipTypeChoices.TYPE_MANY_TO_MANY_SYMMETRIC,
             ),
         ]
 
 
+@skip
 class RelationshipTest(RelationshipBaseTest):  # TODO: BaseModelTestCase mixin?
     def test_clean_filter_not_dict(self):
         m2m = Relationship(
-            name="Another Vlan to Rack",
-            slug="vlan-rack-2",
+            label="Another Vlan to Rack",
+            key="vlan_rack_2",
             source_type=self.location_ct,
             source_filter=["a list not a dict"],
             destination_type=self.rack_ct,
@@ -164,8 +168,8 @@ class RelationshipTest(RelationshipBaseTest):  # TODO: BaseModelTestCase mixin?
 
     def test_clean_filter_not_valid(self):
         m2m = Relationship(
-            name="Another Vlan to Rack",
-            slug="vlan-rack-2",
+            label="Another Vlan to Rack",
+            key="vlan_rack_2",
             source_type=self.location_ct,
             source_filter={"notvalid": "not a location"},
             destination_type=self.rack_ct,
@@ -178,8 +182,8 @@ class RelationshipTest(RelationshipBaseTest):  # TODO: BaseModelTestCase mixin?
         self.assertEqual(handler.exception.message_dict, expected_errors)
 
         m2m = Relationship(
-            name="Another Vlan to Rack",
-            slug="vlan-rack-2",
+            label="Another Vlan to Rack",
+            key="vlan_rack_2",
             source_type=self.location_ct,
             source_filter={"parent": "not a list"},
             destination_type=self.rack_ct,
@@ -192,8 +196,8 @@ class RelationshipTest(RelationshipBaseTest):  # TODO: BaseModelTestCase mixin?
         self.assertEqual(handler.exception.message_dict, expected_errors)
 
         m2m = Relationship(
-            name="Another Vlan to Rack",
-            slug="vlan-rack-2",
+            label="Another Vlan to Rack",
+            key="vlan_rack_2",
             source_type=self.location_ct,
             source_filter={"parent": ["not a valid location"]},
             destination_type=self.rack_ct,
@@ -211,8 +215,8 @@ class RelationshipTest(RelationshipBaseTest):  # TODO: BaseModelTestCase mixin?
 
     def test_clean_valid(self):
         m2m = Relationship(
-            name="Another Vlan to Rack",
-            slug="vlan-rack-2",
+            label="Another Vlan to Rack",
+            key="vlan_rack_2",
             source_type=self.location_ct,
             source_filter={"name": [self.locations[1].slug]},
             destination_type=self.rack_ct,
@@ -225,8 +229,8 @@ class RelationshipTest(RelationshipBaseTest):  # TODO: BaseModelTestCase mixin?
     def test_clean_invalid_asymmetric(self):
         """For a symmetric relationship, source and destination properties must match if specified."""
         o2os = Relationship(
-            name="Location to Location",
-            slug="location-to-location",
+            label="Location to Location",
+            key="location_to_location",
             source_type=self.location_ct,
             source_label="Location A",
             source_hidden=True,
@@ -252,8 +256,8 @@ class RelationshipTest(RelationshipBaseTest):  # TODO: BaseModelTestCase mixin?
         expected_exception = ValidationError({"required_on": ["Symmetric relationships cannot be marked as required."]})
         with self.assertRaises(ValidationError) as err:
             Relationship(
-                name="This shouldn't validate",
-                slug="vlans-vlans-m2m",
+                label="This shouldn't validate",
+                key="vlans_vlans_m2m",
                 type="symmetric-many-to-many",
                 source_type=self.vlan_ct,
                 destination_type=self.vlan_ct,
@@ -262,8 +266,8 @@ class RelationshipTest(RelationshipBaseTest):  # TODO: BaseModelTestCase mixin?
         self.assertEqual(expected_exception, err.exception)
         with self.assertRaises(ValidationError) as err:
             Relationship(
-                name="This shouldn't validate",
-                slug="vlans-vlans-o2o",
+                label="This shouldn't validate",
+                key="vlans_vlans_o2o",
                 type="symmetric-one-to-one",
                 source_type=self.vlan_ct,
                 destination_type=self.vlan_ct,
@@ -274,8 +278,8 @@ class RelationshipTest(RelationshipBaseTest):  # TODO: BaseModelTestCase mixin?
     def test_clean_valid_symmetric_implicit(self):
         """For a symmetric relationship, omitted relevant properties are autofilled on clean."""
         o2os = Relationship(
-            name="Location to Location",
-            slug="location-to-location",
+            label="Location to Location",
+            key="location_to_location",
             source_type=self.location_ct,
             destination_type=self.location_ct,
             source_label="Location",
@@ -327,7 +331,6 @@ class RelationshipTest(RelationshipBaseTest):  # TODO: BaseModelTestCase mixin?
         self.assertTrue(self.m2ms_1.has_many("peer"))
 
     def test_to_form_field_m2m(self):
-
         field = self.m2m_1.to_form_field("source")
         self.assertFalse(field.required)
         self.assertIsInstance(field, DynamicModelMultipleChoiceField)
@@ -348,7 +351,6 @@ class RelationshipTest(RelationshipBaseTest):  # TODO: BaseModelTestCase mixin?
         self.assertEqual(field.query_params, {})
 
     def test_to_form_field_o2m(self):
-
         field = self.o2m_1.to_form_field("source")
         self.assertFalse(field.required)
         self.assertIsInstance(field, DynamicModelMultipleChoiceField)
@@ -375,8 +377,52 @@ class RelationshipTest(RelationshipBaseTest):  # TODO: BaseModelTestCase mixin?
         self.assertIsInstance(field, DynamicModelChoiceField)
         self.assertEqual(field.label, "rack")
 
+    def test_check_if_key_is_graphql_safe(self):
+        """
+        Check the GraphQL validation method on CustomField Key Attribute.
+        """
+        # Check if it catches the cr.key starting with a digit.
+        cr1 = Relationship(
+            label="Vlans to Vlans",
+            key="12_vlans_to_vlans",
+            type="symmetric-many-to-many",
+            source_type=self.vlan_ct,
+            destination_type=self.vlan_ct,
+        )
+        with self.assertRaises(ValidationError) as error:
+            cr1.validated_save()
+        self.assertIn(
+            "This key is not Python/GraphQL safe. Please do not start the key with a digit and do not use hyphens or whitespace",
+            str(error.exception),
+        )
+        # Check if it catches the cr.key with whitespace.
+        cr1.key = "test 1"
+        with self.assertRaises(ValidationError) as error:
+            cr1.validated_save()
+        self.assertIn(
+            "This key is not Python/GraphQL safe. Please do not start the key with a digit and do not use hyphens or whitespace",
+            str(error.exception),
+        )
+        # Check if it catches the cr.key with hyphens.
+        cr1.key = "test-1-relationship"
+        with self.assertRaises(ValidationError) as error:
+            cr1.validated_save()
+        self.assertIn(
+            "This key is not Python/GraphQL safe. Please do not start the key with a digit and do not use hyphens or whitespace",
+            str(error.exception),
+        )
+        # Check if it catches the cr.key with special characters
+        cr1.key = "test_1_rela)(&dship"
+        with self.assertRaises(ValidationError) as error:
+            cr1.validated_save()
+        self.assertIn(
+            "This key is not Python/GraphQL safe. Please do not start the key with a digit and do not use hyphens or whitespace",
+            str(error.exception),
+        )
+
 
-class RelationshipAssociationTest(RelationshipBaseTest):  # TODO: BaseModelTestCase mixin?
+@skip
+class RelationshipAssociationTest(RelationshipBaseTest):
     def setUp(self):
         super().setUp()
 
@@ -413,8 +459,8 @@ class RelationshipAssociationTest(RelationshipBaseTest):  # TODO: BaseModelTestC
         """Test creation of invalid relationship association restricted by destination/source filter."""
 
         relationship = Relationship.objects.create(
-            name="Location to Rack Rel 1",
-            slug="location-to-rack-rel-1",
+            label="Location to Rack Rel 1",
+            key="location_to_rack_rel_1",
             source_type=self.location_ct,
             source_filter={"name": [self.locations[0].name]},
             destination_type=self.rack_ct,
@@ -701,7 +747,7 @@ class RelationshipAssociationTest(RelationshipBaseTest):  # TODO: BaseModelTestC
                 "has_many": False,
                 "label": "Alphabetically Subsequent",
                 "peer_type": self.location_ct,
-                "url": reverse("dcim:location", kwargs={"slug": self.locations[0].slug}),
+                "url": reverse("dcim:location", kwargs={"pk": self.locations[0].pk}),
                 "value": self.locations[0],
             },
         )
@@ -767,11 +813,12 @@ class RelationshipAssociationTest(RelationshipBaseTest):  # TODO: BaseModelTestC
         initial_count = RelationshipAssociation.objects.count()
         # Create new locations because protected error might be raised if we use test fixtures here.
         location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
         locations = (
-            Location.objects.create(name="new location 1", location_type=location_type),
-            Location.objects.create(name="new location 2", location_type=location_type),
-            Location.objects.create(name="new location 3", location_type=location_type),
-            Location.objects.create(name="new location 4", location_type=location_type),
+            Location.objects.create(name="new location 1", location_type=location_type, status=location_status),
+            Location.objects.create(name="new location 2", location_type=location_type, status=location_status),
+            Location.objects.create(name="new location 3", location_type=location_type, status=location_status),
+            Location.objects.create(name="new location 4", location_type=location_type, status=location_status),
         )
         associations = [
             RelationshipAssociation(relationship=self.m2m_1, source=self.racks[0], destination=self.vlans[0]),
@@ -846,6 +893,7 @@ class RelationshipAssociationTest(RelationshipBaseTest):  # TODO: BaseModelTestC
         self.assertEqual(1, RelationshipAssociation.objects.filter(destination_dcim_location=self.locations[0]).count())
 
 
+@skip
 class RelationshipTableTest(RelationshipBaseTest):
     """
     Test inclusion of relationships in object table views.
@@ -904,8 +952,8 @@ class RelationshipTableTest(RelationshipBaseTest):
 
         # Test non-symmetric many to many with same source_type and same destination_type
         self.m2m_same_type = Relationship(
-            name="Location to Location",
-            slug="location-to-location",
+            label="Location to Location",
+            key="location_to_location",
             source_type=self.location_ct,
             destination_type=self.location_ct,
             type=RelationshipTypeChoices.TYPE_MANY_TO_MANY,
@@ -932,50 +980,50 @@ class RelationshipTableTest(RelationshipBaseTest):
         location_table = LocationTable(queryset)
 
         relationship_column_expected = {
-            "location-vlan_src": [
+            "location_vlan_src": [
                 format_html(
                     '<a href="{}?relationship={}&{}_id={}">{} {}</a>',
                     reverse("extras:relationshipassociation_list"),
-                    cr_1.relationship.slug,
+                    cr_1.relationship.key,
                     "source",
                     self.locations[0].id,
                     2,
                     "VLANs",
                 )
             ],
-            "primary-rack-location_dst": [
+            "primary_rack_location_dst": [
                 f'<a href="{self.racks[0].get_absolute_url()}">{self.racks[0].__str__()}</a>'
             ],
-            "alphabetical-locations_src": [
+            "alphabetical_locations_src": [
                 f'<a href="{self.locations[1].get_absolute_url()}">{self.locations[1].__str__()}</a>'
             ],
-            "related-locations_peer": [
+            "related_locations_peer": [
                 format_html(
                     '<a href="{}?relationship={}&{}_id={}">{} {}</a>',
                     reverse("extras:relationshipassociation_list"),
-                    cr_5.relationship.slug,
+                    cr_5.relationship.key,
                     "peer",
                     self.locations[0].id,
                     2,
                     "locations",
                 )
             ],
-            "location-to-location_src": [
+            "location_to_location_src": [
                 format_html(
                     '<a href="{}?relationship={}&{}_id={}">{} {}</a>',
                     reverse("extras:relationshipassociation_list"),
-                    cr_7.relationship.slug,
+                    cr_7.relationship.key,
                     "source",
                     self.locations[0].id,
                     1,
                     "location",
                 )
             ],
-            "location-to-location_dst": [
+            "location_to_location_dst": [
                 format_html(
                     '<a href="{}?relationship={}&{}_id={}">{} {}</a>',
                     reverse("extras:relationshipassociation_list"),
-                    cr_8.relationship.slug,
+                    cr_8.relationship.key,
                     "destination",
                     self.locations[0].id,
                     1,
@@ -1000,7 +1048,6 @@ class RelationshipTableTest(RelationshipBaseTest):
 
 class RequiredRelationshipTestMixin(TestCase):
     def send_data(self, model_class, data, interact_with, action="add", url_kwargs=None):
-
         # Helper to post data to a URL
 
         if interact_with == "ui":
@@ -1062,8 +1109,8 @@ class RequiredRelationshipTestMixin(TestCase):
         circuittype_ct = ContentType.objects.get_for_model(CircuitType)
         vlan_ct = ContentType.objects.get_for_model(VLAN)
         relationship_m2m = Relationship(
-            name="VLANs require at least one Device",
-            slug="vlans-devices-m2m",
+            label="VLANs require at least one Device",
+            key="vlans_devices_m2m",
             type="many-to-many",
             source_type=device_ct,
             destination_type=vlan_ct,
@@ -1071,8 +1118,8 @@ class RequiredRelationshipTestMixin(TestCase):
         )
         relationship_m2m.validated_save()
         relationship_o2m = Relationship(
-            name="Platforms require at least one device",
-            slug="platform-devices-o2m",
+            label="Platforms require at least one device",
+            key="platform_devices_o2m",
             type="one-to-many",
             source_type=platform_ct,
             destination_type=device_ct,
@@ -1080,8 +1127,8 @@ class RequiredRelationshipTestMixin(TestCase):
         )
         relationship_o2m.validated_save()
         relationship_o2o = Relationship(
-            name="Circuit type requires one platform",
-            slug="circuittype-platform-o2o",
+            label="Circuit type requires one platform",
+            key="circuittype_platform_o2o",
             type="one-to-one",
             source_type=circuittype_ct,
             destination_type=platform_ct,
@@ -1095,7 +1142,7 @@ class RequiredRelationshipTestMixin(TestCase):
                 "create_data": {
                     "vid": "1",
                     "name": "New VLAN",
-                    "status": str(Status.objects.get_for_model(VLAN).get(slug="active").pk),
+                    "status": str(Status.objects.get_for_model(VLAN).first().pk),
                 },
                 "relationship": relationship_m2m,
                 "required_objects_generator": [
@@ -1106,7 +1153,7 @@ class RequiredRelationshipTestMixin(TestCase):
                     "api": {
                         "objects_nonexistent": "VLANs require at least one device, but no devices exist yet. "
                         "Create a device by posting to /api/dcim/devices/",
-                        "objects_not_specified": 'You need to specify ["relationships"]["vlans-devices-m2m"]'
+                        "objects_not_specified": 'You need to specify ["relationships"]["vlans_devices_m2m"]'
                         '["source"]["objects"].',
                     },
                     "ui": {
@@ -1128,7 +1175,7 @@ class RequiredRelationshipTestMixin(TestCase):
                     "api": {
                         "objects_nonexistent": "Platforms require at least one device, but no devices exist yet. "
                         "Create a device by posting to /api/dcim/devices/",
-                        "objects_not_specified": 'You need to specify ["relationships"]["platform-devices-o2m"]'
+                        "objects_not_specified": 'You need to specify ["relationships"]["platform_devices_o2m"]'
                         '["destination"]["objects"].',
                     },
                     "ui": {
@@ -1145,13 +1192,13 @@ class RequiredRelationshipTestMixin(TestCase):
                 },
                 "relationship": relationship_o2o,
                 "required_objects_generator": [
-                    lambda: Platform.objects.create(name="New Platform 2", slug="new-platform-2", napalm_args="null")
+                    lambda: Platform.objects.create(name="New Platform 2", napalm_args="null")
                 ],
                 "expected_errors": {
                     "api": {
                         "objects_nonexistent": "Circuit types require a platform, but no platforms exist yet. "
                         "Create a platform by posting to /api/dcim/platforms/",
-                        "objects_not_specified": 'You need to specify ["relationships"]["circuittype-platform-o2o"]'
+                        "objects_not_specified": 'You need to specify ["relationships"]["circuittype_platform_o2o"]'
                         '["destination"]["objects"].',
                     },
                     "ui": {
@@ -1168,22 +1215,20 @@ class RequiredRelationshipTestMixin(TestCase):
             self.client.force_login(self.user)
 
         for params in tests_params:
-
             required_on = params["relationship"].required_on
             target_side = RelationshipSideChoices.OPPOSITE[required_on]
             from_model = getattr(params["relationship"], f"{required_on}_type").model_class()
             to_model = getattr(params["relationship"], f"{target_side}_type").model_class()
 
-            test_msg = f"Testing {from_model._meta.verbose_name} relationship '{params['relationship'].slug}'"
+            test_msg = f"Testing {from_model._meta.verbose_name} relationship '{params['relationship'].key}'"
             with self.subTest(msg=test_msg):
-
                 # Clear any existing required target model objects that may have been created in previous subTests
                 to_model.objects.all().delete()
 
                 # Get count of existing objects:
                 existing_count = from_model.objects.count()
 
-                related_field_name = params["relationship"].slug
+                related_field_name = params["relationship"].key
                 if interact_with == "ui":
                     related_field_name = f"cr_{related_field_name}__{target_side}"
 
@@ -1263,7 +1308,6 @@ class RequiredRelationshipTestMixin(TestCase):
                 self.assertEqual(from_model.objects.count(), existing_count + 1)
 
                 if interact_with == "api":
-
                     """
                     - Relationship is marked as being not required
                     - Object is created without the required relationship data (succeeds)

nautobot/extras/tests/test_tags.py

@@ -18,14 +18,6 @@ class TaggedItemORMTest(TestCase):
 
         cls.location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
 
-    def test_tags_set_taggit_1(self):
-        """Test that obj.tags.set() works when invoked like django-taggit 1.x."""
-        self.location.tags.set("Tag 1", "Tag 2")
-        self.assertListEqual(sorted([t.name for t in self.location.tags.all()]), ["Tag 1", "Tag 2"])
-
-        self.location.tags.set(Tag.objects.get(name="Tag 1"))
-        self.assertListEqual(sorted([t.name for t in self.location.tags.all()]), ["Tag 1"])
-
     def test_tags_set_taggit_2(self):
         """Test that obj.tags.set() works when invoked like django-taggit 2.x and later."""
         self.location.tags.set(["Tag 1", "Tag 2"])
@@ -47,7 +39,6 @@ class TaggedItemTest(APITestCase):
         cls.location_type = LocationType.objects.get(name="Campus")
 
     def test_create_tagged_item(self):
-
         data = {
             "name": "Test Location",
             "slug": "test-location",
@@ -60,7 +51,8 @@ class TaggedItemTest(APITestCase):
 
         response = self.client.post(url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_201_CREATED)
-        self.assertListEqual(sorted([t["id"] for t in response.data["tags"]]), sorted(data["tags"]))
+        # response with default depth is a list of tag URLs
+        self.assertEqual(sorted(response.data["tags"]), sorted([self.absolute_api_url(t) for t in self.tags]))
         location = Location.objects.get(pk=response.data["id"])
         self.assertListEqual(sorted([t.name for t in location.tags.all()]), sorted([t.name for t in self.tags]))
 
@@ -79,9 +71,10 @@ class TaggedItemTest(APITestCase):
 
         response = self.client.patch(url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
+        # response with default depth is a list of tag URLs
         self.assertListEqual(
-            sorted([t["name"] for t in response.data["tags"]]),
-            sorted([t["name"] for t in data["tags"]]),
+            sorted(response.data["tags"]),
+            sorted([self.absolute_api_url(t) for t in [self.tags[0], self.tags[1], self.tags[3]]]),
         )
         location = Location.objects.get(pk=response.data["id"])
         self.assertListEqual(
@@ -111,6 +104,7 @@ class TaggedItemTest(APITestCase):
             "slug": "test-location",
             "status": Status.objects.get_for_model(Location).first().pk,
             "tags": [tag.id],
+            "location_type": self.location_type.pk,
         }
         url = reverse("dcim-api:location-list")
         self.add_permissions("dcim.add_location")