nautobot 2.4.21__py3-none-any.whl → 3.0.0a3__py3-none-any.whl

nautobot/core/tests/test_forms.py

@@ -6,7 +6,7 @@ from django import forms as django_forms
 from django.apps import apps as django_apps
 from django.contrib.contenttypes.models import ContentType
 from django.http import QueryDict
-from django.test import TestCase
+from django.test import tag
 from django.urls import reverse
 from django_filters.filterset import FilterSet
 from netaddr import IPNetwork
@@ -20,19 +20,7 @@ from nautobot.extras import filters as extras_filters, models as extras_models
 from nautobot.ipam import forms as ipam_forms, models as ipam_models
 
 
-class SearchFormTestCase(TestCase):
-    def test_q_placeholder(self):
-        from nautobot.core.forms import SearchForm
-
-        self.assertEqual(SearchForm().fields["q"].widget.attrs["placeholder"], "Search")
-
-        # Assert the q field placeholder is overridden
-        self.assertEqual(
-            SearchForm(q_placeholder="Search Locations").fields["q"].widget.attrs["placeholder"], "Search Locations"
-        )
-
-
-class ExpandIPAddress(TestCase):
+class ExpandIPAddress(testing.TestCase):
     """
     Validate the operation of expand_ipaddress_pattern().
     """
@@ -215,7 +203,7 @@ class ExpandIPAddress(TestCase):
             sorted(forms.expand_ipaddress_pattern("1.2.3.[4,,5]/32", 4))
 
 
-class ExpandAlphanumeric(TestCase):
+class ExpandAlphanumeric(testing.TestCase):
     """
     Validate the operation of expand_alphanumeric_pattern().
     """
@@ -349,7 +337,7 @@ class ExpandAlphanumeric(TestCase):
             sorted(forms.expand_alphanumeric_pattern("r[a,,b]a"))
 
 
-class AddFieldToFormClassTest(TestCase):
+class AddFieldToFormClassTest(testing.TestCase):
     def test_field_added(self):
         """
         Test adding of a new field to an existing form.
@@ -378,7 +366,7 @@ class AddFieldToFormClassTest(TestCase):
             )
 
 
-class DynamicModelChoiceFieldTest(TestCase):
+class DynamicModelChoiceFieldTest(testing.TestCase):
     """Tests for DynamicModelChoiceField."""
 
     def setUp(self):
@@ -414,7 +402,7 @@ class DynamicModelChoiceFieldTest(TestCase):
         self.assertEqual(self.field_with_to_field_name.prepare_value(address), address.address)
 
 
-class DynamicModelMultipleChoiceFieldTest(TestCase):
+class DynamicModelMultipleChoiceFieldTest(testing.TestCase):
     """Tests for DynamicModelMultipleChoiceField."""
 
     def setUp(self):
@@ -451,7 +439,7 @@ class DynamicModelMultipleChoiceFieldTest(TestCase):
         )
 
 
-class MultiValueCharFieldTest(TestCase):
+class MultiValueCharFieldTest(testing.TestCase):
     def setUp(self):
         self.filter = filters.MultiValueCharFilter()
         self.field = forms.MultiValueCharField()
@@ -484,7 +472,7 @@ class MultiValueCharFieldTest(TestCase):
         )
 
 
-class NumericArrayFieldTest(TestCase):
+class NumericArrayFieldTest(testing.TestCase):
     def setUp(self):
         super().setUp()
         # We need to use a field with required=False so we can test empty/None inputs
@@ -514,7 +502,7 @@ class NumericArrayFieldTest(TestCase):
                 self.field.clean(test)
 
 
-class AddressFieldMixinTest(TestCase):
+class AddressFieldMixinTest(testing.TestCase):
     """Test cases for the AddressFieldMixin."""
 
     def setUp(self):
@@ -544,7 +532,7 @@ class AddressFieldMixinTest(TestCase):
             mock_init.assert_called_with(initial=self.initial, instance=self.ip)
 
 
-class PrefixFieldMixinTest(TestCase):
+class PrefixFieldMixinTest(testing.TestCase):
     """Test cases for the PrefixFieldMixin."""
 
     def setUp(self):
@@ -593,7 +581,7 @@ class JSONFieldTest(testing.TestCase):
         self.assertEqual('"I am UTF-8! 😀"', forms.JSONField().prepare_value("I am UTF-8! 😀"))
 
 
-class MultiMatchModelMultipleChoiceFieldTest(TestCase):
+class MultiMatchModelMultipleChoiceFieldTest(testing.TestCase):
     def test_clean(self):
         field = forms.MultiMatchModelMultipleChoiceField(
             queryset=ipam_models.VLANGroup.objects.all(), to_field_name="name"
@@ -621,14 +609,14 @@ class MultiMatchModelMultipleChoiceFieldTest(TestCase):
                 field.clean(value)
 
 
-class WidgetsTest(TestCase):
+class WidgetsTest(testing.TestCase):
     def test_api_select_add_query_param_with_utf8(self):
         widget = forms.APISelect()
         widget.add_query_param("utf8", "I am UTF-8! 😀")
         self.assertEqual('["I am UTF-8! 😀"]', widget.attrs["data-query-param-utf8"])
 
 
-class DynamicFilterFormTest(TestCase):
+class DynamicFilterFormTest(testing.TestCase):
     def test_get_filterset_parameter_form_field_all_filters(self):
         """
         Test every FilterSet to validate that Plural names are correctly mapped in get_filterset_parameter_form_field.
@@ -671,6 +659,7 @@ class DynamicFilterFormTest(TestCase):
     #         DynamicFilterForm()
     #     self.assertEqual("'DynamicFilterForm' object requires `filterset_class` attribute", str(err.exception))
 
+    @tag("example_app")
     def test_dynamic_filter_form(self):
         form = forms.DynamicFilterForm(filterset=extras_filters.StatusFilterSet())
         location_form = forms.DynamicFilterForm(filterset=dcim_filters.LocationFilterSet())
@@ -678,7 +667,6 @@ class DynamicFilterFormTest(TestCase):
 
         with self.subTest("Assert get_lookup_field_choices"):
             self.assertEqual(
-                form._get_lookup_field_choices(),
                 [
                     ("color", "Color"),
                     ("contacts", "Contacts (name or ID)"),
@@ -690,13 +678,13 @@ class DynamicFilterFormTest(TestCase):
                     ("name", "Name"),
                     ("teams", "Teams (name or ID)"),
                 ],
+                form._get_lookup_field_choices(),
             )
             self.assertEqual(
-                location_form._get_lookup_field_choices(),
                 [
                     ("asn", "ASN"),
                     ("child_location_type", "Child location type (name or ID)"),
-                    ("circuit_terminations", "Circuit terminations"),
+                    ("circuit_terminations", "Circuit terminations (ID)"),
                     ("clusters", "Clusters (name or ID)"),
                     ("comments", "Comments"),
                     ("contact_email", "Contact E-mail"),
@@ -729,9 +717,9 @@ class DynamicFilterFormTest(TestCase):
                     ("parent", "Parent location (name or ID)"),
                     ("physical_address", "Physical address"),
                     ("power_panels", "Power panels (name or ID)"),
-                    ("prefixes", "Prefixes"),
-                    ("racks", "Rack (name or ID)"),
+                    ("prefixes", "Prefixes (ID)"),
                     ("rack_groups", "Rack groups (name or ID)"),
+                    ("racks", "Racks (name or ID)"),
                     ("shipping_address", "Shipping address"),
                     ("status", "Status (name or ID)"),
                     ("vlans", "Tagged VLANs (VID or ID)"),
@@ -743,6 +731,7 @@ class DynamicFilterFormTest(TestCase):
                     ("time_zone", "Time zone"),
                     ("vlan_groups", "VLAN groups (name or ID)"),
                 ],
+                location_form._get_lookup_field_choices(),
             )
 
         with self.subTest(

nautobot/core/tests/test_graphql.py

@@ -17,8 +17,7 @@ from django.urls import reverse
 import graphene.types
 from graphene_django.registry import get_global_registry
 from graphene_django.settings import graphene_settings
-from graphql import get_default_backend, GraphQLError
-from graphql.error.located_error import GraphQLLocatedError
+from graphql import execute, get_introspection_query, graphql_sync, GraphQLError, parse
 import redis.exceptions
 from rest_framework import status
 
@@ -39,6 +38,7 @@ from nautobot.core.graphql.schema import (
 from nautobot.core.graphql.types import DateType, OptimizedNautobotObjectType
 from nautobot.core.graphql.utils import str_to_var_name
 from nautobot.core.testing import create_test_user, NautobotTestClient, TestCase
+from nautobot.core.utils.cache import construct_cache_key
 from nautobot.dcim.choices import ConsolePortTypeChoices, InterfaceModeChoices, InterfaceTypeChoices, PortTypeChoices
 from nautobot.dcim.filters import DeviceFilterSet, LocationFilterSet
 from nautobot.dcim.graphql.types import DeviceType as DeviceTypeGraphQL
@@ -99,7 +99,9 @@ User = get_user_model()
 
 class GraphQLTestCaseBase(TestCase):
     def setUp(self):
-        self.SCHEMA = graphene_settings.SCHEMA  # not a no-op; this causes the schema to be built when first called
+        self.SCHEMA = (
+            graphene_settings.SCHEMA.graphql_schema
+        )  # not a no-op; this causes the schema to be built when first called
 
 
 class GraphQLTestCase(GraphQLTestCaseBase):
@@ -109,7 +111,7 @@ class GraphQLTestCase(GraphQLTestCaseBase):
         GraphQLQuery.objects.create(name="GQL 1", query="{ query: locations {name} }")
         GraphQLQuery.objects.create(name="GQL 2", query="query ($name: [String!]) { locations(name:$name) {name} }")
         self.location_type = LocationType.objects.get(name="Campus")
-        location_status = Status.objects.get_for_model(Location).first()
+        location_status = Status.objects.get_for_model(Location)[0]
         self.locations = (
             Location.objects.create(name="Location-1", location_type=self.location_type, status=location_status),
             Location.objects.create(name="Location-2", location_type=self.location_type, status=location_status),
@@ -119,9 +121,9 @@ class GraphQLTestCase(GraphQLTestCaseBase):
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_execute_query(self):
         query = "{ query: locations {name} }"
-        resp = execute_query(query, user=self.user).to_dict()
-        self.assertFalse(resp["data"].get("error"))
-        self.assertEqual(len(resp["data"]["query"]), Location.objects.all().count())
+        resp = execute_query(query, user=self.user)
+        self.assertIsNone(resp.errors)
+        self.assertEqual(len(resp.data["query"]), Location.objects.all().count())
 
     @skip("Works in isolation, fails as part of the overall test suite due to issue #446")
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
@@ -136,8 +138,8 @@ class GraphQLTestCase(GraphQLTestCaseBase):
         self.locations[0]._custom_field_data = custom_field_data
         self.locations[0].save()
         query = "query ($name: [String!]) { locations(name:$name) {name, _custom_field_data, cf_custom_date_field} }"
-        resp = execute_query(query, user=self.user, variables={"name": "Location-1"}).to_dict()
-        self.assertEqual(resp["data"]["locations"]["cf_custom_date_field"], custom_field_data)
+        resp = execute_query(query, user=self.user, variables={"name": "Location-1"})
+        self.assertEqual(resp.data["locations"]["cf_custom_date_field"], custom_field_data)
 
     @skip("Works in isolation, fails as part of the overall test suite due to issue #446")
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
@@ -152,28 +154,28 @@ class GraphQLTestCase(GraphQLTestCaseBase):
         self.locations[0]._custom_field_data = custom_field_data
         self.locations[0].save()
         query = "query ($name: [String!]) { locations(name:$name) {name, _custom_field_data, cf_custom_json_field} }"
-        resp = execute_query(query, user=self.user, variables={"name": "Location-1"}).to_dict()
-        self.assertEqual(resp["data"]["locations"]["cf_custom_json_field"], custom_field_data)
+        resp = execute_query(query, user=self.user, variables={"name": "Location-1"})
+        self.assertEqual(resp.data["locations"]["cf_custom_json_field"], custom_field_data)
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_execute_query_with_variable(self):
         query = "query ($name: [String!]) { locations(name:$name) {name} }"
-        resp = execute_query(query, user=self.user, variables={"name": "Location-1"}).to_dict()
-        self.assertFalse(resp.get("error"))
-        self.assertEqual(len(resp["data"]["locations"]), 1)
+        resp = execute_query(query, user=self.user, variables={"name": "Location-1"})
+        self.assertIsNone(resp.errors)
+        self.assertEqual(len(resp.data["locations"]), 1)
 
     def test_execute_query_with_error(self):
         query = "THIS TEST WILL ERROR"
         with self.assertRaises(GraphQLError):
-            execute_query(query, user=self.user).to_dict()
+            execute_query(query, user=self.user)
 
     def test_execute_saved_query(self):
-        resp = execute_saved_query("GQL 1", user=self.user).to_dict()
-        self.assertFalse(resp["data"].get("error"))
+        resp = execute_saved_query("GQL 1", user=self.user)
+        self.assertIsNone(resp.errors)
 
     def test_execute_saved_query_with_variable(self):
-        resp = execute_saved_query("GQL 2", user=self.user, variables={"name": "location-1"}).to_dict()
-        self.assertFalse(resp["data"].get("error"))
+        resp = execute_saved_query("GQL 2", user=self.user, variables={"name": "location-1"})
+        self.assertIsNone(resp.errors)
 
     def test_graphql_types_registry(self):
         """Ensure models with graphql feature are registered in the graphene_django registry."""
@@ -186,8 +188,8 @@ class GraphQLTestCase(GraphQLTestCaseBase):
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_graphql_url_field(self):
         """Test the url field for all graphql types."""
-        schema = self.SCHEMA.introspect()
-        graphql_fields = schema["__schema"]["types"][0]["fields"]
+        introspection_query_result = graphql_sync(self.SCHEMA, get_introspection_query(descriptions=False))
+        graphql_fields = introspection_query_result.data["__schema"]["types"][0]["fields"]
         for graphql_field in graphql_fields:
             if graphql_field["type"]["kind"] == "LIST" or graphql_field["name"] == "content_type":
                 continue
@@ -208,12 +210,12 @@ class GraphQLTestCase(GraphQLTestCaseBase):
                     query = f'{{ query: {graphql_field["name"]}(id:"{obj.pk}") {{ url }} }}'
                     request = RequestFactory(SERVER_NAME="nautobot.example.com").post("/graphql/")
                     request.user = self.user
-                    resp = execute_query(query, request=request).to_dict()
+                    resp = execute_query(query, request=request)
                     self.assertIsNotNone(
-                        resp["data"]["query"]["url"], f"No url returned in graphql for {graphql_field['name']}"
+                        resp.data["query"]["url"], f"No url returned in graphql for {graphql_field['name']}"
                     )
                     self.assertTrue(
-                        resp["data"]["query"]["url"].endswith(f"/{obj.pk}/"),
+                        resp.data["query"]["url"].endswith(f"/{obj.pk}/"),
                         f"Mismatched url returned in graphql for {graphql_field['name']}",
                     )
 
@@ -228,13 +230,13 @@ class GraphQLUtilsTestCase(GraphQLTestCaseBase):
 class GraphQLGenerateSchemaTypeTestCase(GraphQLTestCaseBase):
     def test_model_w_filterset(self):
         schema = generate_schema_type(app_name="dcim", model=Device)
-        self.assertEqual(schema.__bases__[0], OptimizedNautobotObjectType)
+        self.assertIn(OptimizedNautobotObjectType, schema.__bases__)
         self.assertEqual(schema._meta.model, Device)
         self.assertEqual(schema._meta.filterset_class, DeviceFilterSet)
 
     def test_model_wo_filterset(self):
         schema = generate_schema_type(app_name="wrong_app", model=ChangeLoggedModel)
-        self.assertEqual(schema.__bases__[0], OptimizedNautobotObjectType)
+        self.assertIn(OptimizedNautobotObjectType, schema.__bases__)
         self.assertEqual(schema._meta.model, ChangeLoggedModel)
         self.assertIsNone(schema._meta.filterset_class)
 
@@ -402,8 +404,12 @@ class GraphQLExtendSchemaRelationship(GraphQLTestCaseBase):
     def tearDown(self):
         """Ensure that relationship caches are cleared to avoid leakage into other tests."""
         with contextlib.suppress(redis.exceptions.ConnectionError):
-            cache.delete_pattern(f"{Relationship.objects.get_for_model_source.cache_key_prefix}.*")
-            cache.delete_pattern(f"{Relationship.objects.get_for_model_destination.cache_key_prefix}.*")
+            cache.delete_pattern(
+                f"{construct_cache_key(Relationship.objects, method_name='get_for_model_source', branch_aware=True)}(*)"
+            )
+            cache.delete_pattern(
+                f"{construct_cache_key(Relationship.objects, method_name='get_for_model_destination', branch_aware=True)}(*)"
+            )
 
     def test_extend_relationship_default_prefix(self):
         """Verify that relationships are correctly added to the schema."""
@@ -472,14 +478,15 @@ class GraphQLSearchParameters(GraphQLTestCaseBase):
     def test_search_parameters(self):
         fields = LocationFilterSet().filters.keys()
         params = generate_list_search_parameters(self.schema)
-        exclude_filters = ["type"]
+        args_filters = ["description"]
 
         for field in fields:
             field = str_to_var_name(field)
-            if field not in exclude_filters:
-                self.assertIn(field, params.keys())
-            else:
+            if field in args_filters:
                 self.assertNotIn(field, params.keys())
+                self.assertIn(field, params["args"].keys())
+            else:
+                self.assertIn(field, params.keys())
 
 
 class GraphQLAPIPermissionTest(GraphQLTestCaseBase):
@@ -514,7 +521,7 @@ class GraphQLAPIPermissionTest(GraphQLTestCaseBase):
         cls.clients[3].credentials(HTTP_AUTHORIZATION=f"Token {cls.tokens[3].key}")
 
         cls.location_type = LocationType.objects.get(name="Campus")
-        location_status = Status.objects.get_for_model(Location).first()
+        location_status = Status.objects.get_for_model(Location)[0]
         cls.locations = (
             Location.objects.create(name="Location 1", location_type=cls.location_type, status=location_status),
             Location.objects.create(name="Location 2", location_type=cls.location_type, status=location_status),
@@ -544,7 +551,7 @@ class GraphQLAPIPermissionTest(GraphQLTestCaseBase):
             location_obj_permission.groups.add(cls.groups[i])
             location_obj_permission.users.add(cls.users[i])
 
-        rack_status = Status.objects.get_for_model(Rack).first()
+        rack_status = Status.objects.get_for_model(Rack)[0]
         cls.rack_grp1 = (
             Rack.objects.create(name="Rack 1-1", location=cls.locations[0], status=rack_status),
             Rack.objects.create(name="Rack 1-2", location=cls.locations[0], status=rack_status),
@@ -603,14 +610,14 @@ class GraphQLAPIPermissionTest(GraphQLTestCaseBase):
         """Validate that users can query based on their permissions."""
         # First user
         response = self.clients[0].post(self.api_url, {"query": self.get_racks_query}, format="json")
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertIsInstance(response.data["data"]["racks"], list)
         names = [item["name"] for item in response.data["data"]["racks"]]
         self.assertEqual(names, ["Rack 1-1", "Rack 1-2"])
 
         # Second user
         response = self.clients[1].post(self.api_url, {"query": self.get_racks_query}, format="json")
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertIsInstance(response.data["data"]["racks"], list)
         names = [item["name"] for item in response.data["data"]["racks"]]
         self.assertEqual(names, ["Rack 2-1", "Rack 2-2"])
@@ -618,7 +625,7 @@ class GraphQLAPIPermissionTest(GraphQLTestCaseBase):
     def test_graphql_api_token_super_user(self):
         """Validate a superuser can query everything."""
         response = self.clients[2].post(self.api_url, {"query": self.get_racks_query}, format="json")
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertIsInstance(response.data["data"]["racks"], list)
         names = [item["name"] for item in response.data["data"]["racks"]]
         self.assertEqual(names, ["Rack 1-1", "Rack 1-2", "Rack 2-1", "Rack 2-2"])
@@ -626,7 +633,7 @@ class GraphQLAPIPermissionTest(GraphQLTestCaseBase):
     def test_graphql_api_token_no_group(self):
         """Validate users with no permission are not able to query anything by default."""
         response = self.clients[3].post(self.api_url, {"query": self.get_racks_query}, format="json")
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertIsInstance(response.data["data"]["racks"], list)
         names = [item["name"] for item in response.data["data"]["racks"]]
         self.assertEqual(names, [])
@@ -635,7 +642,7 @@ class GraphQLAPIPermissionTest(GraphQLTestCaseBase):
     def test_graphql_api_token_no_group_exempt(self):
         """Validate users with no permission are able to query based on the exempt permissions."""
         response = self.clients[3].post(self.api_url, {"query": self.get_racks_query}, format="json")
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertIsInstance(response.data["data"]["racks"], list)
         names = [item["name"] for item in response.data["data"]["racks"]]
         self.assertEqual(names, ["Rack 1-1", "Rack 1-2", "Rack 2-1", "Rack 2-2"])
@@ -643,18 +650,18 @@ class GraphQLAPIPermissionTest(GraphQLTestCaseBase):
     def test_graphql_api_no_token(self):
         """Validate unauthenticated users are not able to query anything."""
         response = self.client.post(self.api_url, {"query": self.get_racks_query}, format="json")
-        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+        self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
 
     def test_graphql_api_wrong_token(self):
         """Validate a wrong token return 403."""
         self.client.credentials(HTTP_AUTHORIZATION="Token zzzzzzzzzzabcdef0123456789abcdef01234567")
         response = self.client.post(self.api_url, {"query": self.get_racks_query}, format="json")
-        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+        self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
 
     def test_graphql_query_params(self):
         """Validate query parameters are available for a model."""
         response = self.clients[2].post(self.api_url, {"query": self.get_racks_params_query}, format="json")
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertIsInstance(response.data["data"]["racks"], list)
         names = [item["name"] for item in response.data["data"]["racks"]]
         self.assertEqual(names, ["Rack 1-1", "Rack 1-2"])
@@ -663,14 +670,14 @@ class GraphQLAPIPermissionTest(GraphQLTestCaseBase):
         """Validate graphql variables are working as expected."""
         payload = {"query": self.get_racks_var_query, "variables": {"location": "Location 1"}}
         response = self.clients[2].post(self.api_url, payload, format="json")
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertIsInstance(response.data["data"]["racks"], list)
         names = [item["name"] for item in response.data["data"]["racks"]]
         self.assertEqual(names, ["Rack 1-1", "Rack 1-2"])
 
         payload = {"query": self.get_racks_var_query, "variables": {"location": "Location 2"}}
         response = self.clients[2].post(self.api_url, payload, format="json")
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertIsInstance(response.data["data"]["racks"], list)
         names = [item["name"] for item in response.data["data"]["racks"]]
         self.assertEqual(names, ["Rack 2-1", "Rack 2-2"])
@@ -679,14 +686,14 @@ class GraphQLAPIPermissionTest(GraphQLTestCaseBase):
         """Validate graphql query for a single object as opposed to a set of objects also works."""
         payload = {"query": self.get_rack_query, "variables": {"id": Rack.objects.first().pk}}
         response = self.clients[2].post(self.api_url, payload, format="json")
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertIsInstance(response.data["data"]["rack"], dict)
         self.assertEqual(response.data["data"]["rack"]["name"], Rack.objects.first().name)
 
     def test_graphql_query_multi_level(self):
         """Validate request with multiple levels return the proper information, following the permissions."""
         response = self.clients[0].post(self.api_url, {"query": self.get_locations_racks_query}, format="json")
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertIsInstance(response.data["data"]["locations"], list)
         self.assertGreater(len(response.data["data"]["locations"]), 0)
         location_names = [item["name"] for item in response.data["data"]["locations"]]
@@ -702,7 +709,7 @@ class GraphQLAPIPermissionTest(GraphQLTestCaseBase):
             data=self.get_locations_racks_query,
             content_type="application/graphql",
         )
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertIsInstance(response.data["data"]["locations"], list)
         location_names = [item["name"] for item in response.data["data"]["locations"]]
         location_list = list(Location.objects.values_list("name", flat=True))
@@ -1114,14 +1121,12 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
         )
         cls.rm2ms_assoc_3.validated_save()
 
-        cls.backend = get_default_backend()
-
     def execute_query(self, query, variables=None):
-        document = self.backend.document_from_string(self.SCHEMA, query)
+        document = parse(query)
         if variables:
-            return document.execute(context_value=self.request, variable_values=variables)
+            return execute(schema=self.SCHEMA, document=document, context_value=self.request, variable_values=variables)
         else:
-            return document.execute(context_value=self.request)
+            return execute(schema=self.SCHEMA, document=document, context_value=self.request)
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_circuit_terminations_cable_peer(self):
@@ -1522,7 +1527,7 @@ query {
 
         response = self.execute_query(query)
         self.assertEqual(len(response.errors), 1)
-        self.assertIsInstance(response.errors[0], GraphQLLocatedError)
+        self.assertIsInstance(response.errors[0], GraphQLError)
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_locations_filter(self):
@@ -1797,6 +1802,11 @@ query {
                 f'device: "{self.device1.name}"',
                 Q(device=self.device1),
             ),
+            (
+                f'type: "{PortTypeChoices.TYPE_8P8C}"',
+                Q(type=PortTypeChoices.TYPE_8P8C),
+            ),
+            # for backward compatibility:
             (
                 f'_type: "{PortTypeChoices.TYPE_8P8C}"',
                 Q(type=PortTypeChoices.TYPE_8P8C),
@@ -1830,7 +1840,7 @@ query {
                 Q(device=self.device1),
             ),
             (
-                f'_type: "{PortTypeChoices.TYPE_8P8C}"',
+                f'type: "{PortTypeChoices.TYPE_8P8C}"',
                 Q(type=PortTypeChoices.TYPE_8P8C),
             ),
         )
@@ -2436,7 +2446,7 @@ query {
         self.device1.primary_ip4 = self.ipaddr1
         self.device1.save()
         result = self.execute_query(query, variables={"device_id": str(self.device1.id)})
-        self.assertNotIn("error", str(result))
+        self.assertIsNone(result.errors)
         expected_interfaces_first = {"ip_addresses": [{"primary_ip4_for": [{"id": str(self.device1.id)}]}]}
         self.assertEqual(result.data["device"]["interfaces"][0], expected_interfaces_first)
 
@@ -2450,12 +2460,12 @@ query {
         query = """query { tenant_groups { name tenants { name } } }"""
         # Prewarm caches of Relationships and such to reduce variation in the number of queries below
         result = self.execute_query(query)
-        self.assertNotIn("error", str(result))
+        self.assertIsNone(result.errors)
         # Run it again and assert that the optimized query is run.
         # Before the fix for #7651 this would result in N+1 queries where N is the number of tenant-groups!
         with self.assertNumQueries(2):
             result = self.execute_query(query)
-        self.assertNotIn("error", str(result))
+        self.assertIsNone(result.errors)
 
 
 class GraphQLTypeTestCase(UnitTestTestCase):

nautobot/core/tests/test_models.py

@@ -130,7 +130,7 @@ class NaturalKeyTestCase(BaseModelTest):
             self.FakeBaseModel._content_type_cached
             self.assertEqual(mock__content_type.call_count, 1)
 
-            time.sleep(2)  # Let the cache expire
+            time.sleep(3)  # Let the cache expire
 
             self.FakeBaseModel._content_type_cached
             self.assertEqual(mock__content_type.call_count, 2)

nautobot/core/tests/test_nautobot_server.py

@@ -13,6 +13,7 @@ from unittest import mock, TestCase
 
 from django import __version__ as django_version
 from django.conf import settings
+from django.test import tag
 
 from nautobot import __version__ as nautobot_version
 
@@ -101,6 +102,7 @@ class NautobotServerTestCase(TestCase):
 
         self.assertNotEqual(secret_key_1, secret_key_2)
 
+    @tag("example_app")
     def test_settings_processing(self):
         result = subprocess.run(
             ["nautobot-server", "--config", settings.SETTINGS_PATH, "print_settings"],