nautobot 2.1.7__py3-none-any.whl → 2.1.9__py3-none-any.whl

nautobot/extras/tests/test_customfields.py

@@ -1,3 +1,4 @@
+import json
 import logging
 
 from django.conf import settings
@@ -42,7 +43,6 @@ class CustomFieldTest(ModelTestCases.BaseModelTestCase, TestCase):
     def test_immutable_fields(self):
         """Some fields may not be changed once set, due to the potential for complex downstream effects."""
         instance = CustomField(
-            # 2.0 TODO: #824 remove name field
             label="Custom Field",
             key="custom_field",
             type=CustomFieldTypeChoices.TYPE_TEXT,
@@ -96,6 +96,11 @@ class CustomFieldTest(ModelTestCases.BaseModelTestCase, TestCase):
                 "field_value": "http://example.com/",
                 "empty_value": "",
             },
+            {
+                "field_type": CustomFieldTypeChoices.TYPE_MARKDOWN,
+                "field_value": "### Hello world!\n\n- Item 1\n- Item 2\n- Item 3",
+                "empty_value": "",
+            },
             {
                 "field_type": CustomFieldTypeChoices.TYPE_JSON,
                 "field_value": {"dict_key": "key value"},
@@ -394,35 +399,57 @@ class CustomFieldManagerTest(TestCase):
         self.assertEqual(CustomField.objects.get_for_model(Location).count(), 2)
         self.assertEqual(CustomField.objects.get_for_model(VirtualMachine).count(), 0)
 
-    def test_get_for_model_lru_cache_invalidation(self):
-        """Test that the lru cache is properly invalidated when CustomFields are created or deleted."""
-
-        qs1 = CustomField.objects.get_for_model(Location)
-
+    def test_get_for_model_caching_and_cache_invalidation(self):
+        """Test that the cache is used and is properly invalidated when CustomFields are created or deleted."""
         # Assert that the cache is used when calling get_for_model a second time
-        qs1_cached = CustomField.objects.get_for_model(Location)
-        self.assertTrue(qs1_cached is qs1)
+        CustomField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            CustomField.objects.get_for_model(Location)
+
+        # Assert that different values of exclude_filter_disabled are cached separately
+        with self.assertNumQueries(1):
+            CustomField.objects.get_for_model(Location, exclude_filter_disabled=True)
+        with self.assertNumQueries(0):
+            CustomField.objects.get_for_model(Location, exclude_filter_disabled=True)
+        with self.assertNumQueries(0):
+            CustomField.objects.get_for_model(Location)
+
+        # Assert that different models are cached separately
+        with self.assertNumQueries(1):
+            CustomField.objects.get_for_model(VirtualMachine)
+        with self.assertNumQueries(0):
+            CustomField.objects.get_for_model(VirtualMachine)
+        with self.assertNumQueries(0):
+            CustomField.objects.get_for_model(Location)
 
         # Assert that the cache is invalidated on object save
         custom_field = CustomField(type=CustomFieldTypeChoices.TYPE_TEXT, label="Test CF1", default="foo")
         custom_field.save()
-        qs2 = CustomField.objects.get_for_model(Location)
-        self.assertFalse(qs2 is qs1)
+        with self.assertNumQueries(1):
+            CustomField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            CustomField.objects.get_for_model(Location)
 
         # Assert that the cache is invalidated when adding a CustomField.content_types m2m relationship
         custom_field.content_types.set([self.content_type])
-        qs3 = CustomField.objects.get_for_model(Location)
-        self.assertNotIn(qs3, (qs1, qs2))
+        with self.assertNumQueries(1):
+            CustomField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            CustomField.objects.get_for_model(Location)
 
         # Assert that the cache is invalidated when removing a CustomField.content_types m2m relationship
         custom_field.content_types.set([])
-        qs4 = CustomField.objects.get_for_model(Location)
-        self.assertNotIn(qs4, (qs1, qs2, qs3))
+        with self.assertNumQueries(1):
+            CustomField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            CustomField.objects.get_for_model(Location)
 
         # Assert that the cache is invalidated on object delete
         custom_field.delete()
-        qs5 = CustomField.objects.get_for_model(Location)
-        self.assertNotIn(qs5, (qs1, qs2, qs3, qs4))
+        with self.assertNumQueries(1):
+            CustomField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            CustomField.objects.get_for_model(Location)
 
 
 class CustomFieldDataAPITest(APITestCase):
@@ -432,130 +459,162 @@ class CustomFieldDataAPITest(APITestCase):
     For tests of the api/extras/custom-fields/ REST API endpoint itself, see test_api.py.
     """
 
-    @classmethod
-    def setUpTestData(cls):
+    user_permissions = (
+        "dcim.add_location",
+        "dcim.change_location",
+        "dcim.view_location",
+    )
+
+    def setUp(self):
+        super().setUp()
         content_type = ContentType.objects.get_for_model(Location)
 
         # Text custom field
-        cls.cf_text = CustomField(
+        self.cf_text = CustomField(
             type=CustomFieldTypeChoices.TYPE_TEXT, label="Text Field", key="text_cf", default="FOO"
         )
-        cls.cf_text.save()
-        cls.cf_text.content_types.set([content_type])
+        self.cf_text.validated_save()
+        self.cf_text.content_types.set([content_type])
 
         # Integer custom field
-        cls.cf_integer = CustomField(
+        self.cf_integer = CustomField(
             type=CustomFieldTypeChoices.TYPE_INTEGER, label="Number Field", key="number_cf", default=12
         )
-        cls.cf_integer.save()
-        cls.cf_integer.content_types.set([content_type])
+        self.cf_integer.validated_save()
+        self.cf_integer.content_types.set([content_type])
 
         # Boolean custom field
-        cls.cf_boolean = CustomField(
+        self.cf_boolean = CustomField(
             type=CustomFieldTypeChoices.TYPE_BOOLEAN,
             label="Boolean Field",
             key="boolean_cf",
             default=False,
         )
-        cls.cf_boolean.save()
-        cls.cf_boolean.content_types.set([content_type])
+        self.cf_boolean.validated_save()
+        self.cf_boolean.content_types.set([content_type])
 
         # Date custom field
-        cls.cf_date = CustomField(
+        self.cf_date = CustomField(
             type=CustomFieldTypeChoices.TYPE_DATE,
             label="Date Field",
             key="date_cf",
             default="2020-01-01",
         )
-        cls.cf_date.save()
-        cls.cf_date.content_types.set([content_type])
+        self.cf_date.validated_save()
+        self.cf_date.content_types.set([content_type])
 
         # URL custom field
-        cls.cf_url = CustomField(
+        self.cf_url = CustomField(
             type=CustomFieldTypeChoices.TYPE_URL,
             label="URL Field",
             key="url_cf",
             default="http://example.com/1",
         )
-        cls.cf_url.save()
-        cls.cf_url.content_types.set([content_type])
+        self.cf_url.validated_save()
+        self.cf_url.content_types.set([content_type])
 
         # Select custom field
-        cls.cf_select = CustomField(
+        self.cf_select = CustomField(
             type=CustomFieldTypeChoices.TYPE_SELECT,
             label="Choice Field",
             key="choice_cf",
         )
-        cls.cf_select.save()
-        cls.cf_select.content_types.set([content_type])
-        CustomFieldChoice.objects.create(custom_field=cls.cf_select, value="Foo")
-        CustomFieldChoice.objects.create(custom_field=cls.cf_select, value="Bar")
-        CustomFieldChoice.objects.create(custom_field=cls.cf_select, value="Baz")
-        cls.cf_select.default = "Foo"
-        cls.cf_select.save()
+        self.cf_select.validated_save()
+        self.cf_select.content_types.set([content_type])
+        CustomFieldChoice.objects.create(custom_field=self.cf_select, value="Foo")
+        CustomFieldChoice.objects.create(custom_field=self.cf_select, value="Bar")
+        CustomFieldChoice.objects.create(custom_field=self.cf_select, value="Baz")
+        self.cf_select.default = "Foo"
+        self.cf_select.validated_save()
 
         # Multi-select custom field
-        cls.cf_multi_select = CustomField(
+        self.cf_multi_select = CustomField(
             type=CustomFieldTypeChoices.TYPE_MULTISELECT,
             label="Multiple Choice Field",
             key="multi_choice_cf",
         )
-        cls.cf_multi_select.save()
-        cls.cf_multi_select.content_types.set([content_type])
-        CustomFieldChoice.objects.create(custom_field=cls.cf_multi_select, value="Foo")
-        CustomFieldChoice.objects.create(custom_field=cls.cf_multi_select, value="Bar")
-        CustomFieldChoice.objects.create(custom_field=cls.cf_multi_select, value="Baz")
-        cls.cf_multi_select.default = ["Foo", "Bar"]
-        cls.cf_multi_select.save()
+        self.cf_multi_select.validated_save()
+        self.cf_multi_select.content_types.set([content_type])
+        CustomFieldChoice.objects.create(custom_field=self.cf_multi_select, value="Foo")
+        CustomFieldChoice.objects.create(custom_field=self.cf_multi_select, value="Bar")
+        CustomFieldChoice.objects.create(custom_field=self.cf_multi_select, value="Baz")
+        self.cf_multi_select.default = ["Foo", "Bar"]
+        self.cf_multi_select.validated_save()
+
+        # Markdown custom field
+        self.cf_markdown = CustomField(
+            type=CustomFieldTypeChoices.TYPE_MARKDOWN,
+            label="Markdown Field",
+            key="markdown_cf",
+            default="# One\n\n## Two\n\n### Three",
+        )
+        self.cf_markdown.validated_save()
+        self.cf_markdown.content_types.set([content_type])
+
+        # JSON custom field
+        self.cf_json = CustomField(
+            type=CustomFieldTypeChoices.TYPE_JSON,
+            label="JSON Field",
+            key="json_cf",
+            default={"dict": ["key1", "key2"]},
+        )
+        self.cf_json.validated_save()
+        self.cf_json.content_types.set([content_type])
+
+        self.all_cfs = [
+            self.cf_text,
+            self.cf_integer,
+            self.cf_boolean,
+            self.cf_date,
+            self.cf_url,
+            self.cf_select,
+            self.cf_multi_select,
+            self.cf_markdown,
+            self.cf_json,
+        ]
 
         if "example_plugin" in settings.PLUGINS:
-            cls.cf_plugin_field = CustomField.objects.get(key="example_plugin_auto_custom_field")
+            self.cf_plugin_field = CustomField.objects.get(key="example_plugin_auto_custom_field")
+            self.all_cfs.append(self.cf_plugin_field)
 
-        cls.statuses = Status.objects.get_for_model(Location)
+        self.statuses = Status.objects.get_for_model(Location)
 
         # Create some locations
-        cls.lt = LocationType.objects.get(name="Campus")
-        cls.locations = (
-            Location.objects.create(name="Location 1", status=cls.statuses[0], location_type=cls.lt),
-            Location.objects.create(name="Location 2", status=cls.statuses[0], location_type=cls.lt),
+        self.lt = LocationType.objects.get(name="Campus")
+        self.locations = (
+            Location.objects.create(name="Location 1", status=self.statuses[0], location_type=self.lt),
+            Location.objects.create(name="Location 2", status=self.statuses[0], location_type=self.lt),
         )
 
         # Assign custom field values for location 2
-        cls.locations[1]._custom_field_data = {
-            cls.cf_text.key: "bar",
-            cls.cf_integer.key: 456,
-            cls.cf_boolean.key: True,
-            cls.cf_date.key: "2020-01-02",
-            cls.cf_url.key: "http://example.com/2",
-            cls.cf_select.key: "Bar",
-            cls.cf_multi_select.key: ["Bar", "Baz"],
+        self.locations[1]._custom_field_data = {
+            self.cf_text.key: "bar",
+            self.cf_integer.key: 456,
+            self.cf_boolean.key: True,
+            self.cf_date.key: "2020-01-02",
+            self.cf_url.key: "http://example.com/2",
+            self.cf_select.key: "Bar",
+            self.cf_multi_select.key: ["Bar", "Baz"],
+            self.cf_markdown.key: "### Hello world!\n\n- Item 1\n- Item 2\n- Item 3",
+            self.cf_json.key: {"hello": "world"},
         }
         if "example_plugin" in settings.PLUGINS:
-            cls.locations[1]._custom_field_data[cls.cf_plugin_field.key] = "Custom value"
-        cls.locations[1].save()
+            self.locations[1]._custom_field_data[self.cf_plugin_field.key] = "Custom value"
+        self.locations[1].validated_save()
+        self.list_url = reverse("dcim-api:location-list")
+        self.detail_url = reverse("dcim-api:location-detail", kwargs={"pk": self.locations[1].pk})
 
     def test_get_single_object_without_custom_field_data(self):
         """
         Validate that custom fields are present on an object even if it has no values defined.
         """
         url = reverse("dcim-api:location-detail", kwargs={"pk": self.locations[0].pk})
-        self.add_permissions("dcim.view_location")
 
         response = self.client.get(url, **self.header)
         self.assertEqual(response.data["name"], self.locations[0].name)
         # A model directly instantiated via the ORM does NOT automatically receive custom field default values.
         # This is arguably a bug. See https://github.com/nautobot/nautobot/issues/3312 for details.
-        expected_data = {
-            "text_cf": None,
-            "number_cf": None,
-            "boolean_cf": None,
-            "date_cf": None,
-            "url_cf": None,
-            "choice_cf": None,
-            "multi_choice_cf": None,
-        }
-        if "example_plugin" in settings.PLUGINS:
-            expected_data["example_plugin_auto_custom_field"] = None
+        expected_data = {cf.key: None for cf in self.all_cfs}
         self.assertEqual(response.data["custom_fields"], expected_data)
 
     def test_get_single_object_with_custom_field_data(self):
@@ -563,18 +622,12 @@ class CustomFieldDataAPITest(APITestCase):
         Validate that custom fields are present and correctly set for an object with values defined.
         """
         location2_cfvs = self.locations[1].cf
-        url = reverse("dcim-api:location-detail", kwargs={"pk": self.locations[1].pk})
-        self.add_permissions("dcim.view_location")
-
-        response = self.client.get(url, **self.header)
+        response = self.client.get(self.detail_url, **self.header)
         self.assertEqual(response.data["name"], self.locations[1].name)
-        self.assertEqual(response.data["custom_fields"]["text_cf"], location2_cfvs["text_cf"])
-        self.assertEqual(response.data["custom_fields"]["number_cf"], location2_cfvs["number_cf"])
-        self.assertEqual(response.data["custom_fields"]["boolean_cf"], location2_cfvs["boolean_cf"])
-        self.assertEqual(response.data["custom_fields"]["date_cf"], location2_cfvs["date_cf"])
-        self.assertEqual(response.data["custom_fields"]["url_cf"], location2_cfvs["url_cf"])
-        self.assertEqual(response.data["custom_fields"]["choice_cf"], location2_cfvs["choice_cf"])
-        self.assertEqual(response.data["custom_fields"]["multi_choice_cf"], location2_cfvs["multi_choice_cf"])
+        for cf in self.all_cfs:
+            self.assertIn(cf.key, response.data["custom_fields"])
+            self.assertIn(cf.key, location2_cfvs)
+            self.assertEqual(response.data["custom_fields"][cf.key], location2_cfvs[cf.key])
 
     def test_create_single_object_with_defaults(self):
         """
@@ -585,35 +638,20 @@ class CustomFieldDataAPITest(APITestCase):
             "location_type": self.lt.pk,
             "status": self.statuses[0].pk,
         }
-        url = reverse("dcim-api:location-list")
-        self.add_permissions("dcim.add_location")
-
-        response = self.client.post(url, data, format="json", **self.header)
+        response = self.client.post(self.list_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_201_CREATED)
 
         # Validate response data
         response_cf = response.data["custom_fields"]
-        self.assertEqual(response_cf["text_cf"], self.cf_text.default)
-        self.assertEqual(response_cf["number_cf"], self.cf_integer.default)
-        self.assertEqual(response_cf["boolean_cf"], self.cf_boolean.default)
-        self.assertEqual(response_cf["date_cf"], self.cf_date.default)
-        self.assertEqual(response_cf["url_cf"], self.cf_url.default)
-        self.assertEqual(response_cf["choice_cf"], self.cf_select.default)
-        self.assertEqual(response_cf["multi_choice_cf"], self.cf_multi_select.default)
-        if "example_plugin" in settings.PLUGINS:
-            self.assertEqual(response_cf["example_plugin_auto_custom_field"], self.cf_plugin_field.default)
+        for cf in self.all_cfs:
+            self.assertIn(cf.key, response_cf)
+            self.assertEqual(response_cf[cf.key], cf.default)
 
         # Validate database data
         location = Location.objects.get(pk=response.data["id"])
-        self.assertEqual(location.cf["text_cf"], self.cf_text.default)
-        self.assertEqual(location.cf["number_cf"], self.cf_integer.default)
-        self.assertEqual(location.cf["boolean_cf"], self.cf_boolean.default)
-        self.assertEqual(str(location.cf["date_cf"]), self.cf_date.default)
-        self.assertEqual(location.cf["url_cf"], self.cf_url.default)
-        self.assertEqual(location.cf["choice_cf"], self.cf_select.default)
-        self.assertEqual(location.cf["multi_choice_cf"], self.cf_multi_select.default)
-        if "example_plugin" in settings.PLUGINS:
-            self.assertEqual(location.cf["example_plugin_auto_custom_field"], self.cf_plugin_field.default)
+        for cf in self.all_cfs:
+            self.assertIn(cf.key, location.cf)
+            self.assertEqual(location.cf[cf.key], cf.default)
 
     def test_create_single_object_with_values(self):
         """
@@ -624,51 +662,35 @@ class CustomFieldDataAPITest(APITestCase):
             "status": self.statuses[0].pk,
             "location_type": self.lt.pk,
             "custom_fields": {
-                "text_cf": "bar",
-                "number_cf": 456,
-                "boolean_cf": True,
-                "date_cf": "2020-01-02",
-                "url_cf": "http://example.com/2",
-                "choice_cf": "Bar",
-                "multi_choice_cf": ["Baz"],
+                self.cf_text.key: "bar",
+                self.cf_integer.key: 456,
+                self.cf_boolean.key: True,
+                self.cf_date.key: "2020-01-02",
+                self.cf_url.key: "http://example.com/2",
+                self.cf_select.key: "Bar",
+                self.cf_multi_select.key: ["Baz"],
+                self.cf_markdown.key: "[hello](http://example.com)",
+                self.cf_json.key: {"foo": "bar"},
             },
         }
         if "example_plugin" in settings.PLUGINS:
             data["custom_fields"]["example_plugin_auto_custom_field"] = "Custom value"
-        url = reverse("dcim-api:location-list")
-        self.add_permissions("dcim.add_location")
-
-        response = self.client.post(url, data, format="json", **self.header)
+        response = self.client.post(self.list_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_201_CREATED)
 
         # Validate response data
         response_cf = response.data["custom_fields"]
         data_cf = data["custom_fields"]
-        self.assertEqual(response_cf["text_cf"], data_cf["text_cf"])
-        self.assertEqual(response_cf["number_cf"], data_cf["number_cf"])
-        self.assertEqual(response_cf["boolean_cf"], data_cf["boolean_cf"])
-        self.assertEqual(response_cf["date_cf"], data_cf["date_cf"])
-        self.assertEqual(response_cf["url_cf"], data_cf["url_cf"])
-        self.assertEqual(response_cf["choice_cf"], data_cf["choice_cf"])
-        self.assertEqual(response_cf["multi_choice_cf"], data_cf["multi_choice_cf"])
-        if "example_plugin" in settings.PLUGINS:
-            self.assertEqual(
-                response_cf["example_plugin_auto_custom_field"], data_cf["example_plugin_auto_custom_field"]
-            )
+        for cf in self.all_cfs:
+            self.assertIn(cf.key, response_cf)
+            self.assertIn(cf.key, data_cf)
+            self.assertEqual(response_cf[cf.key], data_cf[cf.key])
 
         # Validate database data
         location = Location.objects.get(pk=response.data["id"])
-        self.assertEqual(location.cf["text_cf"], data_cf["text_cf"])
-        self.assertEqual(location.cf["number_cf"], data_cf["number_cf"])
-        self.assertEqual(location.cf["boolean_cf"], data_cf["boolean_cf"])
-        self.assertEqual(str(location.cf["date_cf"]), data_cf["date_cf"])
-        self.assertEqual(location.cf["url_cf"], data_cf["url_cf"])
-        self.assertEqual(location.cf["choice_cf"], data_cf["choice_cf"])
-        self.assertEqual(location.cf["multi_choice_cf"], data_cf["multi_choice_cf"])
-        if "example_plugin" in settings.PLUGINS:
-            self.assertEqual(
-                location.cf["example_plugin_auto_custom_field"], data_cf["example_plugin_auto_custom_field"]
-            )
+        for cf in self.all_cfs:
+            self.assertIn(cf.key, location.cf)
+            self.assertEqual(location.cf[cf.key], data_cf[cf.key])
 
     def test_create_multiple_objects_with_defaults(self):
         """
@@ -692,50 +714,37 @@ class CustomFieldDataAPITest(APITestCase):
                 "status": self.statuses[0].pk,
             },
         )
-        url = reverse("dcim-api:location-list")
-        self.add_permissions("dcim.add_location")
-
-        response = self.client.post(url, data, format="json", **self.header)
+        response = self.client.post(self.list_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_201_CREATED)
         self.assertEqual(len(response.data), len(data))
 
         for i, _obj in enumerate(data):
             # Validate response data
             response_cf = response.data[i]["custom_fields"]
-            self.assertEqual(response_cf["text_cf"], self.cf_text.default)
-            self.assertEqual(response_cf["number_cf"], self.cf_integer.default)
-            self.assertEqual(response_cf["boolean_cf"], self.cf_boolean.default)
-            self.assertEqual(response_cf["date_cf"], self.cf_date.default)
-            self.assertEqual(response_cf["url_cf"], self.cf_url.default)
-            self.assertEqual(response_cf["choice_cf"], self.cf_select.default)
-            self.assertEqual(response_cf["multi_choice_cf"], self.cf_multi_select.default)
-            if "example_plugin" in settings.PLUGINS:
-                self.assertEqual(response_cf["example_plugin_auto_custom_field"], self.cf_plugin_field.default)
+            for cf in self.all_cfs:
+                self.assertIn(cf.key, response_cf)
+                self.assertEqual(response_cf[cf.key], cf.default)
 
             # Validate database data
             location = Location.objects.get(pk=response.data[i]["id"])
-            self.assertEqual(location.cf["text_cf"], self.cf_text.default)
-            self.assertEqual(location.cf["number_cf"], self.cf_integer.default)
-            self.assertEqual(location.cf["boolean_cf"], self.cf_boolean.default)
-            self.assertEqual(str(location.cf["date_cf"]), self.cf_date.default)
-            self.assertEqual(location.cf["url_cf"], self.cf_url.default)
-            self.assertEqual(location.cf["choice_cf"], self.cf_select.default)
-            self.assertEqual(location.cf["multi_choice_cf"], self.cf_multi_select.default)
-            if "example_plugin" in settings.PLUGINS:
-                self.assertEqual(location.cf["example_plugin_auto_custom_field"], self.cf_plugin_field.default)
+            for cf in self.all_cfs:
+                self.assertIn(cf.key, location.cf)
+                self.assertEqual(location.cf[cf.key], cf.default)
 
     def test_create_multiple_objects_with_values(self):
         """
         Create a three new locations, each with custom fields defined.
         """
         custom_field_data = {
-            "text_cf": "bar",
-            "number_cf": 456,
-            "boolean_cf": True,
-            "date_cf": "2020-01-02",
-            "url_cf": "http://example.com/2",
-            "choice_cf": "Bar",
-            "multi_choice_cf": ["Foo", "Bar"],
+            self.cf_text.key: "bar",
+            self.cf_integer.key: 456,
+            self.cf_boolean.key: True,
+            self.cf_date.key: "2020-01-02",
+            self.cf_url.key: "http://example.com/2",
+            self.cf_select.key: "Bar",
+            self.cf_multi_select.key: ["Foo", "Bar"],
+            self.cf_markdown.key: "### Heading",
+            self.cf_json.key: {"dict1": {"dict2": {}}},
         }
         if "example_plugin" in settings.PLUGINS:
             custom_field_data["example_plugin_auto_custom_field"] = "Custom value"
@@ -759,43 +768,23 @@ class CustomFieldDataAPITest(APITestCase):
                 "custom_fields": custom_field_data,
             },
         )
-        url = reverse("dcim-api:location-list")
-        self.add_permissions("dcim.add_location")
-
-        response = self.client.post(url, data, format="json", **self.header)
+        response = self.client.post(self.list_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_201_CREATED)
         self.assertEqual(len(response.data), len(data))
 
         for i, _obj in enumerate(data):
             # Validate response data
             response_cf = response.data[i]["custom_fields"]
-            self.assertEqual(response_cf["text_cf"], custom_field_data["text_cf"])
-            self.assertEqual(response_cf["number_cf"], custom_field_data["number_cf"])
-            self.assertEqual(response_cf["boolean_cf"], custom_field_data["boolean_cf"])
-            self.assertEqual(response_cf["date_cf"], custom_field_data["date_cf"])
-            self.assertEqual(response_cf["url_cf"], custom_field_data["url_cf"])
-            self.assertEqual(response_cf["choice_cf"], custom_field_data["choice_cf"])
-            self.assertEqual(response_cf["multi_choice_cf"], custom_field_data["multi_choice_cf"])
-            if "example_plugin" in settings.PLUGINS:
-                self.assertEqual(
-                    response_cf["example_plugin_auto_custom_field"],
-                    custom_field_data["example_plugin_auto_custom_field"],
-                )
+            for cf in self.all_cfs:
+                self.assertIn(cf.key, response_cf)
+                self.assertIn(cf.key, custom_field_data)
+                self.assertEqual(response_cf[cf.key], custom_field_data[cf.key])
 
             # Validate database data
             location = Location.objects.get(pk=response.data[i]["id"])
-            self.assertEqual(location.cf["text_cf"], custom_field_data["text_cf"])
-            self.assertEqual(location.cf["number_cf"], custom_field_data["number_cf"])
-            self.assertEqual(location.cf["boolean_cf"], custom_field_data["boolean_cf"])
-            self.assertEqual(str(location.cf["date_cf"]), custom_field_data["date_cf"])
-            self.assertEqual(location.cf["url_cf"], custom_field_data["url_cf"])
-            self.assertEqual(location.cf["choice_cf"], custom_field_data["choice_cf"])
-            self.assertEqual(location.cf["multi_choice_cf"], custom_field_data["multi_choice_cf"])
-            if "example_plugin" in settings.PLUGINS:
-                self.assertEqual(
-                    location.cf["example_plugin_auto_custom_field"],
-                    custom_field_data["example_plugin_auto_custom_field"],
-                )
+            for cf in self.all_cfs:
+                self.assertIn(cf.key, location.cf)
+                self.assertEqual(location.cf[cf.key], custom_field_data[cf.key])
 
     def test_update_single_object_with_values(self):
         """
@@ -806,114 +795,150 @@ class CustomFieldDataAPITest(APITestCase):
         original_cfvs = {**location.cf}
         data = {
             "custom_fields": {
-                "text_cf": "ABCD",
-                "number_cf": 1234,
+                self.cf_text.key: "ABCD",
+                self.cf_integer.key: 1234,
             },
         }
-        url = reverse("dcim-api:location-detail", kwargs={"pk": self.locations[1].pk})
-        self.add_permissions("dcim.change_location")
-
-        response = self.client.patch(url, data, format="json", **self.header)
+        response = self.client.patch(self.detail_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
 
         # Validate response data
         response_cf = response.data["custom_fields"]
-        self.assertEqual(response_cf["text_cf"], data["custom_fields"]["text_cf"])
-        self.assertEqual(response_cf["number_cf"], data["custom_fields"]["number_cf"])
-        self.assertEqual(response_cf["boolean_cf"], original_cfvs["boolean_cf"])
-        self.assertEqual(response_cf["date_cf"], original_cfvs["date_cf"])
-        self.assertEqual(response_cf["url_cf"], original_cfvs["url_cf"])
-        self.assertEqual(response_cf["choice_cf"], original_cfvs["choice_cf"])
-        self.assertEqual(response_cf["multi_choice_cf"], original_cfvs["multi_choice_cf"])
-        if "example_plugin" in settings.PLUGINS:
-            self.assertEqual(
-                response_cf["example_plugin_auto_custom_field"], original_cfvs["example_plugin_auto_custom_field"]
-            )
+        for cf in self.all_cfs:
+            if cf.key in data["custom_fields"]:
+                self.assertEqual(response_cf[cf.key], data["custom_fields"][cf.key])
+            else:
+                self.assertEqual(response_cf[cf.key], original_cfvs[cf.key])
 
         # Validate database data
         location.refresh_from_db()
-        self.assertEqual(location.cf["text_cf"], data["custom_fields"]["text_cf"])
-        self.assertEqual(
-            location.cf["number_cf"],
-            data["custom_fields"]["number_cf"],
-        )
-        self.assertEqual(location.cf["boolean_cf"], original_cfvs["boolean_cf"])
-        self.assertEqual(location.cf["date_cf"], original_cfvs["date_cf"])
-        self.assertEqual(location.cf["url_cf"], original_cfvs["url_cf"])
-        self.assertEqual(location.cf["choice_cf"], original_cfvs["choice_cf"])
-        self.assertEqual(location.cf["multi_choice_cf"], original_cfvs["multi_choice_cf"])
-        if "example_plugin" in settings.PLUGINS:
-            self.assertEqual(
-                location.cf["example_plugin_auto_custom_field"], original_cfvs["example_plugin_auto_custom_field"]
-            )
-
-    def test_minimum_maximum_values_validation(self):
-        url = reverse("dcim-api:location-detail", kwargs={"pk": self.locations[1].pk})
-        self.add_permissions("dcim.change_location")
+        for cf in self.all_cfs:
+            if cf.key in data["custom_fields"]:
+                self.assertEqual(location.cf[cf.key], data["custom_fields"][cf.key])
+            else:
+                self.assertEqual(location.cf[cf.key], original_cfvs[cf.key])
 
+    def test_integer_minimum_maximum_values_validation(self):
         self.cf_integer.validation_minimum = 10
         self.cf_integer.validation_maximum = 20
         self.cf_integer.save()
 
-        data = {"custom_fields": {"number_cf": 9}}
-        response = self.client.patch(url, data, format="json", **self.header)
+        data = {"custom_fields": {self.cf_integer.key: 9}}
+        response = self.client.patch(self.detail_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
 
-        data = {"custom_fields": {"number_cf": 21}}
-        response = self.client.patch(url, data, format="json", **self.header)
+        data = {"custom_fields": {self.cf_integer.key: 21}}
+        response = self.client.patch(self.detail_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
 
-        data = {"custom_fields": {"number_cf": 15}}
-        response = self.client.patch(url, data, format="json", **self.header)
+        data = {"custom_fields": {self.cf_integer.key: 15}}
+        response = self.client.patch(self.detail_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
 
-    def test_bigint_values_of_custom_field_maximum_attribute(self):
-        url = reverse("dcim-api:location-detail", kwargs={"pk": self.locations[1].pk})
-        self.add_permissions("dcim.change_location")
-
+    def test_integer_bigint_values_of_custom_field_maximum_attribute(self):
         self.cf_integer.validation_maximum = 5000000000
         self.cf_integer.save()
 
-        data = {"custom_fields": {"number_cf": 4294967294}}
-        response = self.client.patch(url, data, format="json", **self.header)
+        data = {"custom_fields": {self.cf_integer.key: 4294967294}}
+        response = self.client.patch(self.detail_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
 
-        data = {"custom_fields": {"number_cf": 5000000001}}
-        response = self.client.patch(url, data, format="json", **self.header)
+        data = {"custom_fields": {self.cf_integer.key: 5000000001}}
+        response = self.client.patch(self.detail_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
 
-    def test_bigint_values_of_custom_field_minimum_attribute(self):
-        url = reverse("dcim-api:location-detail", kwargs={"pk": self.locations[1].pk})
-        self.add_permissions("dcim.change_location")
-
+    def test_integer_bigint_values_of_custom_field_minimum_attribute(self):
         self.cf_integer.validation_minimum = -5000000000
         self.cf_integer.save()
 
-        data = {"custom_fields": {"number_cf": -4294967294}}
-        response = self.client.patch(url, data, format="json", **self.header)
+        data = {"custom_fields": {self.cf_integer.key: -4294967294}}
+        response = self.client.patch(self.detail_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
 
-        data = {"custom_fields": {"number_cf": -5000000001}}
-        response = self.client.patch(url, data, format="json", **self.header)
+        data = {"custom_fields": {self.cf_integer.key: -5000000001}}
+        response = self.client.patch(self.detail_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
 
-    def test_regex_validation(self):
-        url = reverse("dcim-api:location-detail", kwargs={"pk": self.locations[1].pk})
-        self.add_permissions("dcim.change_location")
+    def test_text_minimum_maximum_length_validation(self):
+        # No minimum or maximum length by default
+        data = {
+            "custom_fields": {
+                self.cf_text.key: "",
+                self.cf_url.key: "",
+                self.cf_json.key: "",
+                self.cf_markdown.key: "",
+            }
+        }
+        response = self.client.patch(self.detail_url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+
+        data = {
+            "custom_fields": {
+                self.cf_text.key: "a" * 500,
+                self.cf_url.key: "b" * 500,
+                self.cf_json.key: "c" * 500,
+                self.cf_markdown.key: "d" * 500,
+            }
+        }
+        response = self.client.patch(self.detail_url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+
+        for cf in [self.cf_text, self.cf_url, self.cf_json, self.cf_markdown]:
+            if cf != self.cf_json:
+                cf.validation_minimum = len(cf.default)
+                invalid_value = cf.default[:-1]
+            else:
+                cf.validation_minimum = len(json.dumps(cf.default))
+                invalid_value = {}
+            cf.validated_save()
 
+            try:
+                invalid_data = {"custom_fields": {cf.key: invalid_value}}
+                response = self.client.patch(self.detail_url, invalid_data, format="json", **self.header)
+                self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+
+                valid_data = {"custom_fields": {cf.key: cf.default}}
+                response = self.client.patch(self.detail_url, valid_data, format="json", **self.header)
+                self.assertHttpStatus(response, status.HTTP_200_OK)
+            finally:
+                cf.validation_minimum = None
+                cf.validated_save()
+
+        for cf in [self.cf_text, self.cf_url, self.cf_json, self.cf_markdown]:
+            if cf != self.cf_json:
+                cf.validation_maximum = len(cf.default)
+                invalid_value = cf.default + "1"
+            else:
+                cf.validation_maximum = len(json.dumps(cf.default))
+                invalid_value = json.dumps(cf.default) + "1"
+            cf.validated_save()
+
+            try:
+                invalid_data = {"custom_fields": {cf.key: invalid_value}}
+                response = self.client.patch(self.detail_url, invalid_data, format="json", **self.header)
+                self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+
+                valid_data = {"custom_fields": {cf.key: cf.default}}
+                response = self.client.patch(self.detail_url, valid_data, format="json", **self.header)
+                self.assertHttpStatus(response, status.HTTP_200_OK)
+            finally:
+                cf.validation_maximum = None
+                cf.validated_save()
+
+    def test_regex_validation(self):
         self.cf_text.validation_regex = r"^[A-Z]{3}$"  # Three uppercase letters
         self.cf_text.save()
 
-        data = {"custom_fields": {"text_cf": "ABC123"}}
-        response = self.client.patch(url, data, format="json", **self.header)
+        data = {"custom_fields": {self.cf_text.key: "ABC123"}}
+        response = self.client.patch(self.detail_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
 
-        data = {"custom_fields": {"text_cf": "abc"}}
-        response = self.client.patch(url, data, format="json", **self.header)
+        data = {"custom_fields": {self.cf_text.key: "abc"}}
+        response = self.client.patch(self.detail_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
 
-        data = {"custom_fields": {"text_cf": "ABC"}}
-        response = self.client.patch(url, data, format="json", **self.header)
+        data = {"custom_fields": {self.cf_text.key: "ABC"}}
+        response = self.client.patch(self.detail_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
 
     def test_select_regex_validation(self):
@@ -935,6 +960,26 @@ class CustomFieldDataAPITest(APITestCase):
         response = self.client.post(url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_201_CREATED)
 
+    def test_select_minimum_maximum_validation(self):
+        url = reverse("extras-api:customfieldchoice-list")
+        self.add_permissions("extras.add_customfieldchoice")
+
+        self.cf_select.validation_minimum = len(self.cf_select.default)
+        self.cf_select.validation_maximum = len(self.cf_select.default)
+        self.cf_select.save()
+
+        data = {"custom_field": self.cf_select.id, "value": self.cf_select.default[:-1], "weight": 100}
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+
+        data = {"custom_field": self.cf_select.id, "value": self.cf_select.default + "A", "weight": 100}
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+
+        data = {"custom_field": self.cf_select.id, "value": "q" * len(self.cf_select.default), "weight": 100}
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+
     def test_text_type_with_invalid_values(self):
         """
         Try and create a new location with an invalid value for a text type.
@@ -944,23 +989,20 @@ class CustomFieldDataAPITest(APITestCase):
             "status": self.statuses[0].pk,
             "location_type": self.lt.pk,
             "custom_fields": {
-                "text_cf": ["I", "am", "a", "disallowed", "type"],
+                self.cf_text.key: ["I", "am", "a", "disallowed", "type"],
             },
         }
-        url = reverse("dcim-api:location-list")
-        self.add_permissions("dcim.add_location")
-
-        response = self.client.post(url, data, format="json", **self.header)
+        response = self.client.post(self.list_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
         self.assertIn("Value must be a string", str(response.content))
 
-        data["custom_fields"].update({"text_cf": 2})
-        response = self.client.post(url, data, format="json", **self.header)
+        data["custom_fields"].update({self.cf_text.key: 2})
+        response = self.client.post(self.list_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
         self.assertIn("Value must be a string", str(response.content))
 
-        data["custom_fields"].update({"text_cf": True})
-        response = self.client.post(url, data, format="json", **self.header)
+        data["custom_fields"].update({self.cf_text.key: True})
+        response = self.client.post(self.list_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
         self.assertIn("Value must be a string", str(response.content))
 
@@ -974,9 +1016,7 @@ class CustomFieldDataAPITest(APITestCase):
             "location_type": self.lt.pk,
             "status": self.statuses[0].pk,
         }
-        url = reverse("dcim-api:location-list")
-        self.add_permissions("dcim.add_location")
-        response = self.client.post(url, data, format="json", **self.header)
+        response = self.client.post(self.list_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
         self.assertIn("Required field cannot be empty", str(response.content))
 
@@ -987,7 +1027,7 @@ class CustomFieldDataAPITest(APITestCase):
                 f"Location N,{self.lt.composite_key},{self.statuses[0].name}",
             ]
         )
-        response = self.client.post(url, csvdata, content_type="text/csv", **self.header)
+        response = self.client.post(self.list_url, csvdata, content_type="text/csv", **self.header)
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
         self.assertIn("Required field cannot be empty", str(response.content))
 
@@ -997,12 +1037,10 @@ class CustomFieldDataAPITest(APITestCase):
             "location_type": self.lt.pk,
             "status": self.statuses[0].pk,
             "custom_fields": {
-                "choice_cf": "Frobozz",
+                self.cf_select.key: "Frobozz",
             },
         }
-        url = reverse("dcim-api:location-list")
-        self.add_permissions("dcim.add_location")
-        response = self.client.post(url, data, format="json", **self.header)
+        response = self.client.post(self.list_url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
         self.assertIn("Invalid choice", str(response.content))
 
@@ -1013,7 +1051,7 @@ class CustomFieldDataAPITest(APITestCase):
                 f"Location N,{self.lt.composite_key},{self.statuses[0].name},Frobozz",
             ]
         )
-        response = self.client.post(url, csvdata, content_type="text/csv", **self.header)
+        response = self.client.post(self.list_url, csvdata, content_type="text/csv", **self.header)
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
         self.assertIn("Invalid choice", str(response.content))
 
@@ -1262,7 +1300,6 @@ class CustomFieldModelTest(TestCase):
         """Test that omitting required custom fields raises a ValidationError."""
         label = "Custom Field"
         custom_field = CustomField.objects.create(
-            # 2.0 TODO: #824 remove name field
             label=label,
             key="custom_field",
             type=CustomFieldTypeChoices.TYPE_TEXT,
@@ -1279,7 +1316,6 @@ class CustomFieldModelTest(TestCase):
         """Test that removing required custom fields and then updating an object raises a ValidationError."""
         label = "Custom Field"
         custom_field = CustomField.objects.create(
-            # 2.0 TODO: #824 remove name field
             label=label,
             key="custom_field",
             type=CustomFieldTypeChoices.TYPE_TEXT,
@@ -2158,7 +2194,7 @@ class CustomFieldTableTest(TestCase):
         for col_name, col_expected_value in custom_column_expected.items():
             internal_col_name = "cf_" + col_name
             custom_column = location_table.base_columns.get(internal_col_name)
-            self.assertIsNotNone(custom_column)
+            self.assertIsNotNone(custom_column, internal_col_name)
             self.assertIsInstance(custom_column, CustomFieldColumn)
 
             rendered_value = bound_row.get_cell(internal_col_name)