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

nautobot/extras/tests/test_relationships.py

@@ -24,123 +24,126 @@ 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,
             ),
         ]
@@ -150,8 +153,8 @@ class RelationshipBaseTest(TestCase):
 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,
@@ -165,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,
@@ -179,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,
@@ -193,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,
@@ -212,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,
@@ -226,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,
@@ -253,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,
@@ -263,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,
@@ -275,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",
@@ -374,6 +377,49 @@ 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),
+        )
+
 
 @skip
 class RelationshipAssociationTest(RelationshipBaseTest):
@@ -413,8 +459,8 @@ class RelationshipAssociationTest(RelationshipBaseTest):
         """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):
                 "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):
         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]),
@@ -905,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,
@@ -933,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,
@@ -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,
@@ -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": {
@@ -1151,7 +1198,7 @@ class RequiredRelationshipTestMixin(TestCase):
                     "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": {
@@ -1173,7 +1220,7 @@ class RequiredRelationshipTestMixin(TestCase):
             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()
@@ -1181,7 +1228,7 @@ class RequiredRelationshipTestMixin(TestCase):
                 # 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}"
 

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"])
@@ -59,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]))
 
@@ -78,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(
@@ -110,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")

nautobot/extras/tests/test_utils.py

@@ -1,7 +1,8 @@
 from unittest import mock
 
 from nautobot.core.testing import TestCase
-from nautobot.extras.utils import get_celery_queues, get_worker_count
+from nautobot.extras.registry import registry
+from nautobot.extras.utils import get_celery_queues, get_worker_count, populate_model_features_registry
 
 
 class UtilsTestCase(TestCase):
@@ -47,3 +48,32 @@ class UtilsTestCase(TestCase):
             self.assertEqual(get_worker_count(queue="bulk"), 4)
         with self.subTest("Empty queue"):
             self.assertEqual(get_worker_count(queue="nobody"), 0)
+
+    def test_populate_model_features_registry(self):
+        original_custom_fields_registry = registry["model_features"]["custom_fields"].copy()
+
+        self.assertIn(
+            "circuit", registry["model_features"]["custom_fields"]["circuits"], "Registry should already be populated"
+        )
+
+        populate_model_features_registry()
+        self.assertDictEqual(
+            registry["model_features"]["custom_fields"],
+            original_custom_fields_registry,
+            "Registry should not be modified if refresh flag not set",
+        )
+
+        registry["model_features"]["custom_fields"].pop("circuits")
+        self.assertNotEqual(
+            registry["model_features"]["custom_fields"],
+            original_custom_fields_registry,
+            "Registry should be successfully modified",
+        )
+
+        # Make sure we return to the original state
+        populate_model_features_registry(refresh=True)
+        self.assertDictEqual(
+            registry["model_features"]["custom_fields"],
+            original_custom_fields_registry,
+            "Registry should be restored to original state",
+        )