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

nautobot/core/testing/api.py

@@ -1,8 +1,11 @@
+import csv
+from io import StringIO
 from typing import Optional, Sequence, Union
 
 from django.conf import settings
+from django.contrib.contenttypes.fields import GenericForeignKey
 from django.contrib.contenttypes.models import ContentType
-from django.db.models import ForeignKey
+from django.db.models import ForeignKey, ManyToManyField
 from django.test import override_settings, tag
 from django.urls import reverse
 from django.utils.text import slugify
@@ -10,8 +13,12 @@ from rest_framework import status
 from rest_framework.test import APITransactionTestCase as _APITransactionTestCase
 
 from nautobot.core import testing
+from nautobot.core.api.utils import get_serializer_for_model
+from nautobot.core.models import fields as core_fields
+from nautobot.core.models.tree_queries import TreeModel
 from nautobot.core.testing import mixins, views
 from nautobot.core.utils import lookup
+from nautobot.core.utils.data import is_uuid
 from nautobot.extras import choices as extras_choices
 from nautobot.extras import models as extras_models
 from nautobot.extras import registry
@@ -185,13 +192,26 @@ class APIViewTestCases:
             self.assertHttpStatus(response, status.HTTP_200_OK)
 
     class ListObjectsViewTestCase(APITestCase):
-        brief_fields = []
         choices_fields = None
         filterset = None
 
         def get_filterset(self):
             return self.filterset or lookup.get_filterset_for_model(self.model)
 
+        def get_depth_fields(self):
+            """Get a list of model fields that could be tested with the ?depth query parameter"""
+            depth_fields = []
+            for field in self.model._meta.fields:
+                if not field.name.startswith("_"):
+                    if isinstance(field, (ForeignKey, GenericForeignKey, ManyToManyField, core_fields.TagsField)) and (
+                        # we represent content-types as "app_label.modelname" rather than as FKs
+                        field.related_model != ContentType
+                        # user is a model field on Token but not a field on TokenSerializer
+                        and not (field.name == "user" and self.model == users_models.Token)
+                    ):
+                        depth_fields.append(field.name)
+            return depth_fields
+
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_list_objects_anonymous(self):
             """
@@ -214,24 +234,59 @@ class APIViewTestCases:
                 self.assertEqual(len(response.data["results"]), self._get_queryset().count())
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
-        def test_list_objects_brief(self):
+        def test_list_objects_depth_0(self):
             """
-            GET a list of objects using the "brief" parameter.
+            GET a list of objects using the "?depth=0" parameter.
             """
+            depth_fields = self.get_depth_fields()
             self.add_permissions(f"{self.model._meta.app_label}.view_{self.model._meta.model_name}")
-            url = f"{self._get_list_url()}?brief=1"
+            url = f"{self._get_list_url()}?depth=0"
             response = self.client.get(url, **self.header)
 
             self.assertHttpStatus(response, status.HTTP_200_OK)
             self.assertIsInstance(response.data, dict)
             self.assertIn("results", response.data)
             self.assertEqual(len(response.data["results"]), self._get_queryset().count())
-            self.assertEqual(
-                sorted(response.data["results"][0]),
-                self.brief_fields,
-                "In order to test the brief API parameter the brief fields need to be manually added to "
-                "self.brief_fields. If this is already the case, perhaps the serializer is implemented incorrectly?",
-            )
+
+            for response_data in response.data["results"]:
+                for field in depth_fields:
+                    self.assertIn(field, response_data)
+                    if isinstance(response_data[field], list):
+                        for entry in response_data[field]:
+                            self.assertTrue(is_uuid(entry))
+                    else:
+                        if response_data[field] is not None:
+                            # The response should be a detail API URL, ending in the UUID of the relevant object
+                            # http://nautobot.example.com/api/circuits/providers/<uuid>/
+                            #                                                    ^^^^^^
+                            self.assertTrue(is_uuid(response_data[field].split("/")[-2]))
+
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
+        def test_list_objects_depth_1(self):
+            """
+            GET a list of objects using the "?depth=1" parameter.
+            """
+            depth_fields = self.get_depth_fields()
+            self.add_permissions(f"{self.model._meta.app_label}.view_{self.model._meta.model_name}")
+            url = f"{self._get_list_url()}?depth=1"
+            response = self.client.get(url, **self.header)
+
+            self.assertHttpStatus(response, status.HTTP_200_OK)
+            self.assertIsInstance(response.data, dict)
+            self.assertIn("results", response.data)
+            self.assertEqual(len(response.data["results"]), self._get_queryset().count())
+
+            for response_data in response.data["results"]:
+                for field in depth_fields:
+                    self.assertIn(field, response_data)
+                    if isinstance(response_data[field], list):
+                        for entry in response_data[field]:
+                            self.assertIsInstance(entry, dict)
+                            self.assertTrue(is_uuid(entry["id"]))
+                    else:
+                        if response_data[field] is not None:
+                            self.assertIsInstance(response_data[field], dict)
+                            self.assertTrue(is_uuid(response_data[field]["id"]))
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_list_objects_without_permission(self):
@@ -293,6 +348,48 @@ class APIViewTestCases:
             for entry in response.data["results"]:
                 self.assertIn(str(entry["id"]), [str(instance1.pk), str(instance2.pk)])
 
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
+        def test_list_objects_ascending_ordered(self):
+            # Simple sorting check for models with a "name" field
+            # TreeModels don't support sorting at this time (order_by is not supported by TreeQuerySet)
+            #   They will pass api == queryset tests below but will fail the user expected sort test
+            if hasattr(self.model, "name") and not issubclass(self.model, TreeModel):
+                self.add_permissions(f"{self.model._meta.app_label}.view_{self.model._meta.model_name}")
+                response = self.client.get(f"{self._get_list_url()}?sort=name&limit=3", **self.header)
+                self.assertHttpStatus(response, status.HTTP_200_OK)
+                result_list = list(map(lambda p: p["name"], response.data["results"]))
+                self.assertEqual(
+                    result_list,
+                    list(self._get_queryset().order_by("name").values_list("name", flat=True)[:3]),
+                    "API sort not identical to QuerySet.order_by",
+                )
+
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
+        def test_list_objects_descending_ordered(self):
+            # Simple sorting check for models with a "name" field
+            # TreeModels don't support sorting at this time (order_by is not supported by TreeQuerySet)
+            #   They will pass api == queryset tests below but will fail the user expected sort test
+            if hasattr(self.model, "name") and not issubclass(self.model, TreeModel):
+                self.add_permissions(f"{self.model._meta.app_label}.view_{self.model._meta.model_name}")
+                response = self.client.get(f"{self._get_list_url()}?sort=-name&limit=3", **self.header)
+                self.assertHttpStatus(response, status.HTTP_200_OK)
+                result_list = list(map(lambda p: p["name"], response.data["results"]))
+                self.assertEqual(
+                    result_list,
+                    list(self._get_queryset().order_by("-name").values_list("name", flat=True)[:3]),
+                    "API sort not identical to QuerySet.order_by",
+                )
+
+                response_ascending = self.client.get(f"{self._get_list_url()}?sort=name&limit=3", **self.header)
+                self.assertHttpStatus(response, status.HTTP_200_OK)
+                result_list_ascending = list(map(lambda p: p["name"], response_ascending.data["results"]))
+
+                self.assertNotEqual(
+                    result_list,
+                    result_list_ascending,
+                    "Same results obtained when sorting by name and by -name (QuerySet not ordering)",
+                )
+
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[], STRICT_FILTERING=True)
         def test_list_objects_unknown_filter_strict_filtering(self):
             """
@@ -335,6 +432,64 @@ class APIViewTestCases:
             response = self.client.options(self._get_list_url(), **self.header)
             self.assertHttpStatus(response, status.HTTP_200_OK)
 
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
+        def test_list_objects_csv(self):
+            """
+            GET a list of objects in CSV format as an authenticated user with permission to view some objects.
+            """
+            self.assertGreaterEqual(
+                self._get_queryset().count(),
+                3,
+                f"Test requires the creation of at least three {self.model} instances",
+            )
+            instance1, instance2, instance3 = self._get_queryset()[:3]
+
+            # Add object-level permission
+            obj_perm = users_models.ObjectPermission(
+                name="Test permission",
+                constraints={"pk__in": [instance1.pk, instance2.pk]},
+                actions=["view"],
+            )
+            obj_perm.save()
+            obj_perm.users.add(self.user)
+            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+
+            # Try filtered GET to objects specifying CSV format as a query parameter
+            response_1 = self.client.get(
+                f"{self._get_list_url()}?format=csv&id={instance1.pk}&id={instance3.pk}", **self.header
+            )
+            self.assertHttpStatus(response_1, status.HTTP_200_OK)
+            self.assertEqual(response_1.get("Content-Type"), "text/csv; charset=UTF-8")
+
+            # Try same request specifying CSV format via the ACCEPT header
+            response_2 = self.client.get(
+                f"{self._get_list_url()}?id={instance1.pk}&id={instance3.pk}", **self.header, HTTP_ACCEPT="text/csv"
+            )
+            self.assertHttpStatus(response_2, status.HTTP_200_OK)
+            self.assertEqual(response_2.get("Content-Type"), "text/csv; charset=UTF-8")
+
+            self.maxDiff = None
+            # This check is more useful than it might seem. Any related object that wasn't CSV-converted correctly
+            # will likely be rendered incorrectly as an API URL, and that API URL *will* differ between the
+            # two responses based on the inclusion or omission of the "?format=csv" parameter.
+            self.assertEqual(
+                response_1.content.decode(response_1.charset), response_2.content.decode(response_2.charset)
+            )
+
+            # Load the csv data back into a list of object dicts
+            reader = csv.DictReader(StringIO(response_1.content.decode(response_1.charset)))
+            rows = list(reader)
+            # Should only have one entry (instance1) since we filtered out instance2 and permissions block instance3
+            self.assertEqual(1, len(rows))
+            self.assertEqual(rows[0]["id"], str(instance1.pk))
+            self.assertEqual(rows[0]["display"], getattr(instance1, "display", str(instance1)))
+            if hasattr(self.model, "_custom_field_data"):
+                custom_fields = extras_models.CustomField.objects.get_for_model(self.model)
+                for cf in custom_fields:
+                    self.assertIn(f"cf_{cf.key}", rows[0])
+                    self.assertEqual(rows[0][f"cf_{cf.key}"], instance1._custom_field_data.get(cf.key) or "")
+            # TODO what other generic tests should we run on the data?
+
     class CreateObjectViewTestCase(APITestCase):
         create_data = []
         validation_excluded_fields = []
@@ -390,7 +545,13 @@ class APIViewTestCases:
 
             initial_count = self._get_queryset().count()
             for i, create_data in enumerate(self.create_data):
-                response = self.client.post(self._get_list_url(), create_data, format="json", **self.header)
+                if i == len(self.create_data) - 1:
+                    # Test to see if depth parameter is ignored in POST request.
+                    response = self.client.post(
+                        self._get_list_url() + "?depth=3", create_data, format="json", **self.header
+                    )
+                else:
+                    response = self.client.post(self._get_list_url(), create_data, format="json", **self.header)
                 self.assertHttpStatus(response, status.HTTP_201_CREATED)
                 self.assertEqual(self._get_queryset().count(), initial_count + i + 1)
                 instance = self._get_queryset().get(pk=response.data["id"])
@@ -411,6 +572,56 @@ class APIViewTestCases:
                     self.assertEqual(len(objectchanges), 1)
                     self.assertEqual(objectchanges[0].action, extras_choices.ObjectChangeActionChoices.ACTION_CREATE)
 
+        def test_recreate_object_csv(self):
+            """CSV export an object, delete it, and recreate it via CSV import."""
+            if hasattr(self, "get_deletable_object"):
+                # provided by DeleteObjectViewTestCase mixin
+                instance = self.get_deletable_object()
+            else:
+                # try to do it ourselves
+                instance = testing.get_deletable_objects(self.model, self._get_queryset()).first()
+            if instance is None:
+                self.fail("Couldn't find a single deletable object!")
+
+            # Add object-level permission
+            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["add", "view"])
+            obj_perm.save()
+            obj_perm.users.add(self.user)
+            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+
+            response = self.client.get(self._get_detail_url(instance) + "?format=csv", **self.header)
+            self.assertHttpStatus(response, status.HTTP_200_OK)
+            csv_data = response.content.decode(response.charset)
+
+            serializer_class = get_serializer_for_model(self.model)
+            old_serializer = serializer_class(instance, context={"request": None})
+            old_data = old_serializer.data
+            instance.delete()
+
+            response = self.client.post(self._get_list_url(), csv_data, content_type="text/csv", **self.header)
+            self.assertHttpStatus(response, status.HTTP_201_CREATED, csv_data)
+            # Note that create via CSV is always treated as a bulk-create, and so the response is always a list of dicts
+            new_instance = self._get_queryset().get(pk=response.data[0]["id"])
+            self.assertNotEqual(new_instance.pk, instance.pk)
+
+            new_serializer = serializer_class(new_instance, context={"request": None})
+            new_data = new_serializer.data
+            for field_name, field in new_serializer.fields.items():
+                if field.read_only or field.write_only:
+                    continue
+                if field_name in ["created", "last_updated"]:
+                    self.assertNotEqual(
+                        old_data[field_name],
+                        new_data[field_name],
+                        f"{field_name} should have been updated on delete/recreate but it didn't change!",
+                    )
+                else:
+                    self.assertEqual(
+                        old_data[field_name],
+                        new_data[field_name],
+                        f"{field_name} should have been unchanged on delete/recreate but it differs!",
+                    )
+
         def test_bulk_create_objects(self):
             """
             POST a set of objects in a single request.
@@ -466,6 +677,27 @@ class APIViewTestCases:
             """
             PATCH a single object identified by its ID.
             """
+
+            def strip_serialized_object(this_object):
+                """
+                Only here to work around acceptable differences in PATCH response vs GET response which are known bugs.
+                """
+                # Work around for https://github.com/nautobot/nautobot/issues/3321
+                this_object.pop("last_updated", None)
+                # PATCH response always includes "opt-in" fields, but GET response does not.
+                this_object.pop("computed_fields", None)
+                this_object.pop("config_context", None)
+                this_object.pop("relationships", None)
+
+                for value in this_object.values():
+                    if isinstance(value, dict):
+                        strip_serialized_object(value)
+                    elif isinstance(value, list):
+                        for list_dict in value:
+                            if isinstance(list_dict, dict):
+                                strip_serialized_object(list_dict)
+
+            self.maxDiff = None
             instance = self._get_queryset().first()
             url = self._get_detail_url(instance)
             update_data = self.update_data or getattr(self, "create_data")[0]
@@ -476,8 +708,44 @@ class APIViewTestCases:
             obj_perm.users.add(self.user)
             obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
 
+            # Verify that an empty PATCH results in no change to the object.
+            # This is to catch issues like https://github.com/nautobot/nautobot/issues/3533
+
+            # Add object-level permission for GET
+            obj_perm.actions = ["view"]
+            obj_perm.save()
+            # Get initial serialized object representation
+            get_response = self.client.get(url, **self.header)
+            self.assertHttpStatus(get_response, status.HTTP_200_OK)
+            initial_serialized_object = get_response.json()
+            strip_serialized_object(initial_serialized_object)
+
+            # Redefine object-level permission for PATCH
+            obj_perm.actions = ["change"]
+            obj_perm.save()
+
+            # Send empty PATCH request
+            response = self.client.patch(url, {}, format="json", **self.header)
+            self.assertHttpStatus(response, status.HTTP_200_OK)
+            serialized_object = response.json()
+            strip_serialized_object(serialized_object)
+            self.assertEqual(initial_serialized_object, serialized_object)
+
+            # Verify ObjectChange creation -- yes, even though nothing actually changed
+            # This may change (hah) at some point -- see https://github.com/nautobot/nautobot/issues/3321
+            if hasattr(self.model, "to_objectchange"):
+                objectchanges = lookup.get_changes_for_model(instance)
+                self.assertEqual(len(objectchanges), 1)
+                self.assertEqual(objectchanges[0].action, extras_choices.ObjectChangeActionChoices.ACTION_UPDATE)
+                objectchanges.delete()
+
+            # Verify that a PATCH with some data updates that data correctly.
             response = self.client.patch(url, update_data, format="json", **self.header)
             self.assertHttpStatus(response, status.HTTP_200_OK)
+            # Check for unexpected side effects on fields we DIDN'T intend to update
+            for field in initial_serialized_object:
+                if field not in update_data:
+                    self.assertEqual(initial_serialized_object[field], serialized_object[field])
             instance.refresh_from_db()
             self.assertInstanceEqual(instance, update_data, exclude=self.validation_excluded_fields, api=True)
 
@@ -487,6 +755,36 @@ class APIViewTestCases:
                 self.assertEqual(len(objectchanges), 1)
                 self.assertEqual(objectchanges[0].action, extras_choices.ObjectChangeActionChoices.ACTION_UPDATE)
 
+        def test_get_put_round_trip(self):
+            """GET and then PUT an object and verify that it's accepted and unchanged."""
+            self.maxDiff = None
+            # Add object-level permission
+            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["view", "change"])
+            obj_perm.save()
+            obj_perm.users.add(self.user)
+            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+
+            instance = self._get_queryset().first()
+            url = self._get_detail_url(instance)
+
+            # GET object representation
+            opt_in_fields = getattr(get_serializer_for_model(self.model).Meta, "opt_in_fields", None)
+            if opt_in_fields:
+                url += "?" + "&".join([f"include={field}" for field in opt_in_fields])
+            get_response = self.client.get(url, **self.header)
+            self.assertHttpStatus(get_response, status.HTTP_200_OK)
+            initial_serialized_object = get_response.json()
+
+            # PUT same object representation
+            put_response = self.client.put(url, initial_serialized_object, format="json", **self.header)
+            self.assertHttpStatus(put_response, status.HTTP_200_OK, initial_serialized_object)
+            updated_serialized_object = put_response.json()
+
+            # Work around for https://github.com/nautobot/nautobot/issues/3321
+            initial_serialized_object.pop("last_updated", None)
+            updated_serialized_object.pop("last_updated", None)
+            self.assertEqual(initial_serialized_object, updated_serialized_object)
+
         def test_bulk_update_objects(self):
             """
             PATCH a set of objects in a single request.
@@ -522,36 +820,6 @@ class APIViewTestCases:
                     api=True,
                 )
 
-        @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
-        def test_options_objects_returns_display_and_value(self):
-            """
-            Make an OPTIONS request for a list endpoint and validate choices use the display and value keys.
-            """
-            # Save self.user as superuser to be able to view available choices on list views.
-            self.user.is_superuser = True
-            self.user.save()
-
-            response = self.client.options(self._get_list_url(), **self.header)
-            self.assertHttpStatus(response, status.HTTP_200_OK)
-            data = response.json()
-
-            self.assertIn("actions", data)
-
-            # Grab any field that has choices defined (fields with enums)
-            if "POST" in data["actions"]:
-                field_choices = {k: v["choices"] for k, v in data["actions"]["POST"].items() if "choices" in v}
-            elif "PUT" in data["actions"]:  # JobModelViewSet supports editing but not creation
-                field_choices = {k: v["choices"] for k, v in data["actions"]["PUT"].items() if "choices" in v}
-            else:
-                self.fail(f"Neither PUT nor POST are available actions in: {data['actions']}")
-
-            # Will successfully assert if field_choices has entries and will not fail if model as no enum choices
-            # Broken down to provide better failure messages
-            for field, choices in field_choices.items():
-                for choice in choices:
-                    self.assertIn("display", choice, f"A choice in {field} is missing the display key")
-                    self.assertIn("value", choice, f"A choice in {field} is missing the value key")
-
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_options_returns_expected_choices(self):
             """
@@ -571,11 +839,25 @@ class APIViewTestCases:
 
             self.assertIn("actions", data)
 
-            # Grab any field name that has choices defined (fields with enums)
-            if "POST" in data["actions"]:
-                field_choices = {k for k, v in data["actions"]["POST"].items() if "choices" in v}
-            elif "PUT" in data["actions"]:  # JobModelViewSet supports editing but not creation
-                field_choices = {k for k, v in data["actions"]["PUT"].items() if "choices" in v}
+            # Grab any field that has choices defined (fields with enums)
+            if any(
+                [
+                    "POST" in data["actions"],
+                    "PUT" in data["actions"],
+                ]
+            ):
+                schema = data["schema"]
+                props = schema["properties"]
+                fields = props.keys()
+                field_choices = set()
+                for field_name in fields:
+                    obj = props[field_name]
+                    if "enum" in obj and "enumNames" in obj:
+                        enum = obj["enum"]
+                        # Zipping to assert that the enum and the mapping have the same number of items.
+                        model_field_choices = dict(zip(obj["enumNames"], enum))
+                        self.assertEqual(len(enum), len(model_field_choices))
+                        field_choices.add(field_name)
             else:
                 self.fail(f"Neither PUT nor POST are available actions in: {data['actions']}")
 
@@ -686,6 +968,39 @@ class APIViewTestCases:
                 self.assertIn("notes_url", response.data)
                 self.assertIn(f"{url}notes/", str(response.data["notes_url"]))
 
+    class TreeModelAPIViewTestCaseMixin:
+        """Test `?depth=2` query parameter for TreeModel"""
+
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
+        def test_list_objects_depth_2(self):
+            """
+            GET a list of objects using the "?depth=2" parameter.
+            TreeModel Only
+            """
+            field = "parent"
+
+            self.add_permissions(f"{self.model._meta.app_label}.view_{self.model._meta.model_name}")
+            url = f"{self._get_list_url()}?depth=2"
+            response = self.client.get(url, **self.header)
+
+            self.assertHttpStatus(response, status.HTTP_200_OK)
+            self.assertIsInstance(response.data, dict)
+            self.assertIn("results", response.data)
+            self.assertEqual(len(response.data["results"]), self._get_queryset().count())
+
+            response_data = response.data["results"]
+            for data in response_data:
+                # First Level Parent
+                self.assertEqual(field in data, True)
+                if data[field] is not None:
+                    self.assertIsInstance(data[field], dict)
+                    self.assertTrue(is_uuid(data[field]["id"]))
+                    # Second Level Parent
+                    self.assertIn(field, data[field])
+                    if data[field][field] is not None:
+                        self.assertIsInstance(data[field][field], dict)
+                        self.assertTrue(is_uuid(data[field][field]["id"]))
+
     class APIViewTestCase(
         GetObjectViewTestCase,
         ListObjectsViewTestCase,

nautobot/core/testing/filters.py

@@ -119,7 +119,7 @@ class FilterTestCases:
             """Test all `RelatedMembershipBooleanFilter` filters found in `self.filterset.get_filters()`.
 
             This test asserts that `filter=True` matches `self.queryset.filter(field__isnull=False)` and
-            that `filter=False` matches `self.queryset.filter(field__isnull=False)`.
+            that `filter=False` matches `self.queryset.filter(field__isnull=True)`.
             """
             for filter_name, filter_object in self.filterset.get_filters().items():
                 if not isinstance(filter_object, RelatedMembershipBooleanFilter):

nautobot/core/testing/migrations.py

@@ -1,3 +1,4 @@
+from unittest import skip
 from django.apps import apps
 from django.core.management import call_command
 from django.db import connection
@@ -5,6 +6,7 @@ from django.db.migrations.executor import MigrationExecutor
 from django.test import TestCase
 
 
+@skip("TODO: Havoc has been wreaked on migrations in 2.0, so this test is currently broken.")
 class NautobotDataMigrationTest(TestCase):
     @property
     def app(self):

nautobot/core/testing/mixins.py

@@ -9,8 +9,7 @@ from django.db.models import JSONField, ManyToManyField
 from django.forms.models import model_to_dict
 from django.utils.text import slugify
 from netaddr import IPNetwork
-from rest_framework.test import APIClient
-from taggit.managers import TaggableManager
+from rest_framework.test import APIClient, APIRequestFactory
 
 from nautobot.core import testing
 from nautobot.core.models import fields as core_fields
@@ -93,7 +92,7 @@ class NautobotTestCaseMixin:
                 field = None
 
             # Handle ManyToManyFields
-            if value and isinstance(field, (ManyToManyField, TaggableManager)):
+            if value and isinstance(field, (ManyToManyField, core_fields.TagsField)):
                 # Only convert ContentType to <app_label>.<model> for API serializers/views
                 if api and field.related_model is ContentType:
                     model_dict[key] = sorted([f"{ct.app_label}.{ct.model}" for ct in value])
@@ -150,14 +149,13 @@ class NautobotTestCaseMixin:
         if isinstance(expected_status, int):
             expected_status = [expected_status]
         if response.status_code not in expected_status:
+            err_message = f"Expected HTTP status(es) {expected_status}; received {response.status_code}:"
             if hasattr(response, "data"):
                 # REST API response; pass the response data through directly
-                err = response.data
-            else:
-                # Attempt to extract form validation errors from the response HTML
-                form_errors = testing.extract_form_failures(response.content.decode(response.charset))
-                err = form_errors or response.content.decode(response.charset) or "No data"
-            err_message = f"Expected HTTP status(es) {expected_status}; received {response.status_code}: {err}"
+                err_message += f"\n{response.data}"
+            # Attempt to extract form validation errors from the response HTML
+            form_errors = testing.extract_form_failures(response.content.decode(response.charset))
+            err_message += "\n" + str(form_errors or response.content.decode(response.charset) or "No data")
             if msg:
                 err_message = f"{msg}\n{err_message}"
         self.assertIn(response.status_code, expected_status, err_message)
@@ -183,6 +181,9 @@ class NautobotTestCaseMixin:
             if isinstance(v, list):
                 # Sort lists of values. This includes items like tags, or other M2M fields
                 new_model_dict[k] = sorted(v)
+            elif k == "data_schema" and isinstance(v, str):
+                # Standardize the data_schema JSON, since the column is JSON and MySQL/dolt do not guarantee order
+                new_model_dict[k] = self.standardize_json(v)
             else:
                 new_model_dict[k] = v
 
@@ -193,6 +194,9 @@ class NautobotTestCaseMixin:
                 if isinstance(v, list):
                     # Sort lists of values. This includes items like tags, or other M2M fields
                     relevant_data[k] = sorted(v)
+                elif k == "data_schema" and isinstance(v, str):
+                    # Standardize the data_schema JSON, since the column is JSON and MySQL/dolt do not guarantee order
+                    relevant_data[k] = self.standardize_json(v)
                 else:
                     relevant_data[k] = v
 
@@ -210,6 +214,15 @@ class NautobotTestCaseMixin:
     # Convenience methods
     #
 
+    def absolute_api_url(self, obj):
+        """Get the absolute API URL ("http://nautobot.example.com/api/...") for a given object."""
+        request = APIRequestFactory(SERVER_NAME="nautobot.example.com").get("")
+        return request.build_absolute_uri(obj.get_absolute_url(api=True))
+
+    def standardize_json(self, data):
+        obj = json.loads(data)
+        return json.dumps(obj, sort_keys=True)
+
     @classmethod
     def create_tags(cls, *names):
         """

nautobot/core/testing/schema.py

@@ -4,6 +4,7 @@ import yaml
 from django.conf import settings
 from django.core.management import call_command
 from django.test import tag
+from rest_framework.settings import api_settings
 
 from nautobot.core.testing import views
 
@@ -18,7 +19,7 @@ class OpenAPISchemaTestCases:
             # We could load the schema from the /api/swagger.yaml endpoint in setUp(self) via self.client,
             # but it's fairly expensive to do so. Better to do so only once per class.
             cls.schemas = {}
-            for api_version in settings.REST_FRAMEWORK_ALLOWED_VERSIONS:
+            for api_version in api_settings.ALLOWED_VERSIONS:
                 out = StringIO()
                 err = StringIO()
                 call_command("spectacular", "--api-version", api_version, stdout=out, stderr=err)