nautobot 2.4.17__py3-none-any.whl → 2.4.19__py3-none-any.whl

nautobot/core/testing/views.py

@@ -1,4 +1,5 @@
 import contextlib
+import inspect
 import re
 from typing import Optional, Sequence
 from unittest import mock, skipIf
@@ -9,8 +10,10 @@ from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.core.validators import URLValidator
+from django.db import connection
 from django.db.models import ManyToManyField, Model, QuerySet
 from django.test import override_settings, tag, TestCase as _TestCase
+from django.test.utils import CaptureQueriesContext
 from django.urls import NoReverseMatch, reverse
 from django.utils.html import escape
 from django.utils.http import urlencode
@@ -144,6 +147,10 @@ class ViewTestCases:
         """
 
         custom_action_required_permissions = {}
+        # TODO: Expand to other relevant view types, e.g. 'list'.
+        allowed_number_of_tree_queries_per_view_type = {
+            "retrieve": 0,
+        }
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_get_object_anonymous(self):
@@ -180,7 +187,8 @@ class ViewTestCases:
             self.add_permissions(f"{self.model._meta.app_label}.view_{self.model._meta.model_name}")
 
             # Try GET with model-level permission
-            response = self.client.get(instance.get_absolute_url())
+            with CaptureQueriesContext(connection) as capture_queries_context:
+                response = self.client.get(instance.get_absolute_url())
             # The object's display name or string representation should appear in the response body
             self.assertBodyContains(response, escape(getattr(instance, "display", str(instance))))
 
@@ -209,6 +217,22 @@ class ViewTestCases:
                     else:
                         self.assertBodyContains(response, escape(str(instance.cf.get(custom_field.key) or "")))
 
+            # Check that no more than the appropriate number of tree CTE queries have been run.
+            captured_tree_cte_queries = [
+                query["sql"] for query in capture_queries_context.captured_queries if "WITH RECURSIVE" in query["sql"]
+            ]
+            _query_separator = "\n" + ("-" * 10) + "\n" + "NEXT QUERY" + "\n" + ("-" * 10)
+            self.assertEqual(
+                len(captured_tree_cte_queries),
+                self.allowed_number_of_tree_queries_per_view_type["retrieve"],
+                f"This view was expected to execute {self.allowed_number_of_tree_queries_per_view_type['retrieve']}"
+                f" recursive database queries but {len(captured_tree_cte_queries)} were executed."
+                f" If this is expected, please update the {self.__class__.__name__}.allowed_number_of_tree_queries_per_view_type['retrieve']"
+                " property. Care should be taken to only increase these numbers where necessary - recursive queries can become really"
+                " slow with bigger datasets."
+                f" The following queries were used:\n{_query_separator.join(captured_tree_cte_queries)}",
+            )
+
             return response  # for consumption by child test cases if desired
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
@@ -776,6 +800,30 @@ class ViewTestCases:
                 response_body = response.content.decode(response.charset)
                 self.assertNotIn('<i class="mdi mdi-circle-small"></i>', response_body)
 
+        def test_model_properties_as_table_columns_are_not_orderable(self):
+            """
+            Check for table columns that are property-based and not orderable.
+            """
+            table_class = getattr(self.get_list_view(), "table_class", None)
+            if not table_class:
+                return
+
+            queryset = self._get_queryset()
+            table = table_class(queryset)
+            model_cls = table._meta.model
+
+            property_fields = {name for name, _ in inspect.getmembers(model_cls, lambda o: isinstance(o, property))}
+
+            for name, column in table.base_columns.items():
+                if hasattr(column, "order_by") and column.order_by:
+                    continue
+                if name in property_fields and name != "pk":
+                    with self.subTest(column_name=name):
+                        self.assertFalse(
+                            column.orderable,
+                            f"On Table `{table_class.__name__}` the property-based column `{name}` should be orderable=False or use a custom order_by",
+                        )
+
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_list_objects_anonymous(self):
             # Make the request as an unauthenticated user
@@ -1379,10 +1427,6 @@ class ViewTestCases:
             # Expect a 200 status cause we are only rendering the bulk delete table after pressing Delete Selected button.
             self.assertHttpStatus(response, 200)
             response_body = utils.extract_page_body(response.content.decode(response.charset))
-            # Check if all pks is not part of the html.
-            self.assertNotIn(str(first_pk), response_body)
-            self.assertNotIn(str(second_pk), response_body)
-            self.assertNotIn(str(third_pk), response_body)
             self.assertIn("<strong>Warning:</strong> The following operation will delete 2 ", response_body)
             self.assertInHTML('<input type="hidden" name="_all" value="true" />', response_body)
 

nautobot/core/tests/test_breadcrumbs.py

@@ -12,11 +12,14 @@ from nautobot.core.testing import TestCase
 from nautobot.core.ui.breadcrumbs import (
     BaseBreadcrumbItem,
     Breadcrumbs,
+    context_object_attr,
     InstanceBreadcrumbItem,
+    InstanceParentBreadcrumbItem,
     ModelBreadcrumbItem,
     ViewNameBreadcrumbItem,
 )
-from nautobot.dcim.models import Device, LocationType
+from nautobot.dcim.models import Device, Location, LocationType
+from nautobot.extras.models import Status
 
 
 class BreadcrumbItemsTestCase(TestCase):
@@ -150,6 +153,13 @@ class BreadcrumbItemsTestCase(TestCase):
                 self.assertEqual(url, test_case["expected_url"])
                 self.assertEqual(label, test_case["expected_label"])
 
+    def test_model_item_not_format_custom_label(self):
+        item = ModelBreadcrumbItem(model_key="object", label="custom LaBeL")
+        context = Context({"object": self.location_type})
+
+        _, label = item.as_pair(context)
+        self.assertEqual(label, "custom LaBeL")
+
     def test_model_item_from_context(self):
         """Test breadcrumb item with model from context."""
         item = ModelBreadcrumbItem(model_key="object")
@@ -209,6 +219,69 @@ class BreadcrumbItemsTestCase(TestCase):
         self.assertEqual(url, "")
         self.assertEqual(label, "")
 
+    def test_instance_item_not_add_title_casing(self):
+        context = Context({"object": LocationType.objects.create(name="custom name")})
+        item = InstanceBreadcrumbItem()
+
+        _, label = item.as_pair(context)
+        self.assertEqual(label, "custom name")
+
+    def test_instance_item_is_working_with_directly_passed_instance(self):
+        context = Context({})
+        instance = LocationType.objects.create(name="cUsToM CoUnTrY")
+        item = InstanceBreadcrumbItem(instance=instance)
+
+        url, label = item.as_pair(context)
+        self.assertEqual(url, f"/dcim/location-types/{instance.pk}/")
+        self.assertEqual(label, "cUsToM CoUnTrY")
+
+    def test_context_object_attr_works_with_various_breadcrumb_items(self):
+        parent_location_type = LocationType.objects.create(name="Country", nestable=True)
+        location_type = LocationType.objects.create(name="State", parent=parent_location_type)
+        status = Status.objects.get_for_model(Location).first()
+        location = Location.objects.create(name="Pomorskie", location_type=location_type, status=status)
+
+        context = Context({"object": location, "status": status})
+
+        item = InstanceBreadcrumbItem(instance=context_object_attr("location_type"))
+        url, label = item.as_pair(context)
+        self.assertEqual(url, f"/dcim/location-types/{location_type.pk}/")
+        self.assertEqual(label, "Country → State")
+
+        item = BaseBreadcrumbItem(label=context_object_attr("name", context_key="status"))
+        url, label = item.as_pair(context)
+        self.assertEqual(url, "")
+        self.assertEqual(label, status.name)
+
+        item = InstanceBreadcrumbItem(instance=context_object_attr("location_type.parent"))
+        url, label = item.as_pair(context)
+        self.assertEqual(url, f"/dcim/location-types/{parent_location_type.pk}/")
+        self.assertEqual(label, "Country")
+
+    def test_instance_parent_not_add_title_casing(self):
+        parent_location_type = LocationType.objects.create(name="cUsToM CoUnTrY", nestable=True)
+        context = Context({"object": LocationType.objects.create(name="custom name", parent=parent_location_type)})
+        item = InstanceParentBreadcrumbItem()
+
+        _, label = item.as_pair(context)
+        self.assertEqual(label, "cUsToM CoUnTrY")
+
+    def test_instance_parent_is_create_proper_url(self):
+        parent_location_type = LocationType.objects.create(name="Country", nestable=True)
+        location_type = LocationType.objects.create(name="State", parent=parent_location_type)
+
+        context = Context({"object": location_type})
+
+        item = InstanceParentBreadcrumbItem()
+        url, label = item.as_pair(context)
+        self.assertEqual(url, f"/dcim/location-types/?parent={parent_location_type.pk}")
+        self.assertEqual(label, "Country")
+
+        item = InstanceParentBreadcrumbItem(parent_query_param="location", parent_lookup_key="name")
+        url, label = item.as_pair(context)
+        self.assertEqual(url, "/dcim/location-types/?location=Country")
+        self.assertEqual(label, "Country")
+
 
 class BreadcrumbsTestCase(TestCase):
     """Test cases for Breadcrumbs class."""
@@ -260,19 +333,20 @@ class BreadcrumbsTestCase(TestCase):
             "list": [ViewNameBreadcrumbItem(view_name="", label="List Item")],
             "detail": [ViewNameBreadcrumbItem(view_name="", label="Detail Item")],
         }
+        context = Context({})
 
         # Test specific action found
-        result = Breadcrumbs.get_items_for_action(test_items, "list", False)
+        result = Breadcrumbs().get_items_for_action(test_items, "list", False, context)
         self.assertEqual(len(result), 1)
         self.assertEqual(result[0].label, "List Item")
 
         # Test fallback to detail when action not found and detail=True
-        result = Breadcrumbs.get_items_for_action(test_items, "nonexistent", True)
+        result = Breadcrumbs().get_items_for_action(test_items, "nonexistent", True, context)
         self.assertEqual(len(result), 1)
         self.assertEqual(result[0].label, "Detail Item")
 
         # Test no fallback when detail=False
-        result = Breadcrumbs.get_items_for_action(test_items, "nonexistent", False)
+        result = Breadcrumbs().get_items_for_action(test_items, "nonexistent", False, context)
         self.assertEqual(len(result), 0)
         self.assertEqual(result, [])
 

nautobot/core/tests/test_commands.py

@@ -29,10 +29,13 @@ class ManagementCommandTestCase(TestCase):
         # status_code_to_endpoints = collections.defaultdict(list)
         for view_name, value in endpoints_dict.items():
             for endpoint in value:
-                response = self.client.get(endpoint, follow=True)
-                self.assertHttpStatus(
-                    response, 200, f"{view_name}: {endpoint} returns status Code {response.status_code} instead of 200"
-                )
+                with self.subTest(endpoint=endpoint):
+                    response = self.client.get(endpoint, follow=True)
+                    self.assertHttpStatus(
+                        response,
+                        200,
+                        f"{view_name}: {endpoint} returns status Code {response.status_code} instead of 200",
+                    )
 
     def test_check_job_approval_status_no_jobs(self):
         out = StringIO()

nautobot/core/tests/test_graphql.py

@@ -11,7 +11,7 @@ from django.contrib.auth.models import Group
 from django.contrib.contenttypes.models import ContentType
 from django.core.cache import cache
 from django.db.models import Count, Q
-from django.test import override_settings, TestCase
+from django.test import override_settings
 from django.test.client import RequestFactory
 from django.urls import reverse
 import graphene.types
@@ -38,7 +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
+from nautobot.core.testing import create_test_user, NautobotTestClient, TestCase
 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
@@ -1453,9 +1453,7 @@ query {
             # Assert GraphQL returned properties match those expected
             self.assertEqual(console_server_port_entry["connected_console_port"], connected_console_port)
 
-    @skip(
-        "Works in isolation, fails as part of the overall test suite due to issue #446, also something is broken with content types"
-    )
+    @skip("Works in isolation, fails as part of the overall test suite due to issue #446")
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_relationship_associations(self):
         """Test queries involving relationship associations."""
@@ -2442,6 +2440,23 @@ query {
         expected_interfaces_first = {"ip_addresses": [{"primary_ip4_for": [{"id": str(self.device1.id)}]}]}
         self.assertEqual(result.data["device"]["interfaces"][0], expected_interfaces_first)
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_query_optimizer_reverse_lookup(self):
+        """
+        Test query optimization in the case of a query mixing reverse and forward nested lookups.
+
+        See https://github.com/nautobot/nautobot/issues/7651.
+        """
+        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))
+        # 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))
+
 
 class GraphQLTypeTestCase(UnitTestTestCase):
     def test_date_type(self):

nautobot/core/tests/test_jobs.py

@@ -798,7 +798,8 @@ class BulkEditTestCase(TransactionTestCase):
             "BulkEditObjects",
             content_type=self.role_ct.id,
             edit_all=False,
-            filter_query_params={"per_page": 2},
+            filter_query_params={"per_page": [2]},
+            pk_list=pk_list,
             form_data={"pk": pk_list, "color": "aa1409"},
             username=self.user.username,
         )
@@ -818,7 +819,8 @@ class BulkEditTestCase(TransactionTestCase):
             "BulkEditObjects",
             content_type=self.role_ct.id,
             edit_all=False,
-            filter_query_params={"sort": "name"},
+            pk_list=pk_list,
+            filter_query_params={"sort": ["name"]},
             form_data={"pk": pk_list, "color": "aa1409"},
             username=self.user.username,
         )
@@ -872,6 +874,7 @@ class BulkEditTestCase(TransactionTestCase):
             content_type=self.namespace_ct.id,
             edit_all=False,
             filter_query_params={},
+            pk_list=pk_list,
             form_data={
                 "pk": pk_list,
                 "description": "Example description for bulk edit",
@@ -969,15 +972,16 @@ class BulkEditTestCase(TransactionTestCase):
             "nautobot.core.jobs.bulk_actions",
             "BulkEditObjects",
             content_type=self.status_ct.id,
-            edit_all=False,
-            filter_query_params={"name__isw": "A", "sort": "name"},
+            edit_all=True,
+            filter_query_params={"name__isw": ["A"], "sort": ["name"]},
+            pk_list=[str(statuses[0].pk)],
             form_data={
                 "pk": [str(statuses[0].pk)],
                 "color": "aa1409",
             },
             username=self.user.username,
         )
-        self._common_no_error_test_assertion(Status, job_result, 1, name__istartswith="A", color="aa1409")
+        self._common_no_error_test_assertion(Status, job_result, len(statuses), name__istartswith="A", color="aa1409")
         self.assertNotEqual(status_to_ignore.color, "aa1409")
 
     def test_bulk_edit_objects_passing_in_both_pk_list_and_edit_all(self):
@@ -994,7 +998,7 @@ class BulkEditTestCase(TransactionTestCase):
             "BulkEditObjects",
             content_type=self.status_ct.id,
             edit_all=True,
-            filter_query_params={"name__isw": "A"},
+            filter_query_params={"name__isw": ["A"]},
             # pk ignored if edit_all is True
             form_data={
                 "pk": [str(statuses[0].pk)],
@@ -1110,9 +1114,12 @@ class BulkDeleteTestCase(TransactionTestCase):
         job_result = create_job_result_and_run_job(
             "nautobot.core.jobs.bulk_actions",
             "BulkDeleteObjects",
+            username=self.user.username,
             content_type=self.status_ct.id,
+            delete_all=False,
+            filter_query_params={},
             pk_list=statuses_to_delete,
-            username=self.user.username,
+            saved_view_id=None,
         )
         self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         job_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
@@ -1129,19 +1136,19 @@ class BulkDeleteTestCase(TransactionTestCase):
         obj_perm.save()
         obj_perm.users.add(self.user)
         obj_perm.object_types.add(ContentType.objects.get_for_model(Status))
-
         job_result = create_job_result_and_run_job(
             "nautobot.core.jobs.bulk_actions",
             "BulkDeleteObjects",
+            username=self.user.username,
             content_type=self.status_ct.id,
+            delete_all=False,
+            filter_query_params={},
             pk_list=statuses_to_delete,
-            username=self.user.username,
+            saved_view_id=None,
         )
         self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
-        self.assertEqual(
-            error_log.message, "You do not have permissions to delete some of the objects provided in `pk_list`."
-        )
+        self.assertIn("Cannot delete some instances of model", error_log.message)
         self.assertEqual(Status.objects.filter(pk__in=statuses_to_delete).count(), len(statuses_to_delete))
 
     def test_bulk_delete_objects_select_all(self):
@@ -1155,11 +1162,12 @@ class BulkDeleteTestCase(TransactionTestCase):
         job_result = create_job_result_and_run_job(
             "nautobot.core.jobs.bulk_actions",
             "BulkDeleteObjects",
+            username=self.user.username,
             content_type=ContentType.objects.get_for_model(Circuit).id,
             delete_all=True,
-            filter_query_params={"per_page": 10},
+            filter_query_params={"per_page": [10]},
             pk_list=[],
-            username=self.user.username,
+            saved_view_id=None,
         )
         self._common_no_error_test_assertion(Circuit, job_result)
 
@@ -1174,11 +1182,12 @@ class BulkDeleteTestCase(TransactionTestCase):
         job_result = create_job_result_and_run_job(
             "nautobot.core.jobs.bulk_actions",
             "BulkDeleteObjects",
+            username=self.user.username,
             content_type=self.role_ct.id,
             delete_all=False,
             filter_query_params={},
             pk_list=roles_pks,
-            username=self.user.username,
+            saved_view_id=None,
         )
         self._common_no_error_test_assertion(Role, job_result, pk__in=roles_pks)
         self.assertTrue(Role.objects.filter(name=roles_to_ignore.name).exists())
@@ -1192,10 +1201,12 @@ class BulkDeleteTestCase(TransactionTestCase):
         job_result = create_job_result_and_run_job(
             "nautobot.core.jobs.bulk_actions",
             "BulkDeleteObjects",
+            username=self.user.username,
             content_type=self.status_ct.id,
             delete_all=True,
-            filter_query_params={"name__isw": "Example Status", "sort": "name"},
-            username=self.user.username,
+            filter_query_params={"name__isw": ["Example Status"], "sort": ["name"]},
+            pk_list=[],
+            saved_view_id=None,
         )
         self._common_no_error_test_assertion(Status, job_result, name__istartswith="Example Status")
         self.assertTrue(Status.objects.filter(name=status_to_ignore.name).exists())
@@ -1211,11 +1222,12 @@ class BulkDeleteTestCase(TransactionTestCase):
         job_result = create_job_result_and_run_job(
             "nautobot.core.jobs.bulk_actions",
             "BulkDeleteObjects",
+            username=self.user.username,
             content_type=self.role_ct.id,
             delete_all=False,
-            filter_query_params={"name__isw": "Example Status"},
+            filter_query_params={"name__isw": ["Example Status"]},
             pk_list=roles_pks,
-            username=self.user.username,
+            saved_view_id=None,
         )
         self._common_no_error_test_assertion(Role, job_result, pk__in=roles_pks)
         self.assertTrue(Role.objects.filter(name=roles_to_ignore.name).exists())
@@ -1228,10 +1240,11 @@ class BulkDeleteTestCase(TransactionTestCase):
         job_result = create_job_result_and_run_job(
             "nautobot.core.jobs.bulk_actions",
             "BulkDeleteObjects",
+            username=self.user.username,
             content_type=self.status_ct.pk,
             delete_all=True,
-            filter_query_params={"name__isw": "Example Status", "sort": "name"},
+            filter_query_params={"name__isw": ["Example Status"]},
             pk_list=[str(Status.objects.first().pk)],
-            username=self.user.username,
+            saved_view_id=None,
         )
         self._common_no_error_test_assertion(Role, job_result, name__istartswith="Example Status")

nautobot/core/tests/test_tables.py

@@ -18,8 +18,18 @@ class TableTestCase(TestCase):
     def _validate_sorted_tree_queryset_same_with_table_queryset(self, queryset, table_class, field_name):
         with self.subTest(f"Assert sorting {table_class.__name__} on '{field_name}'"):
             table = table_class(queryset.with_tree_fields(), order_by=field_name)
-            table_queryset_data = table.data.data.values_list("pk", flat=True)
-            sorted_queryset = queryset.with_tree_fields().extra(order_by=[field_name]).values_list("pk", flat=True)
+            table_queryset_data = table.data.data.values_list(field_name, flat=True)
+            sorted_queryset = (
+                queryset.with_tree_fields().extra(order_by=[field_name]).values_list(field_name, flat=True)
+            )
+            self.assertEqual(list(table_queryset_data), list(sorted_queryset))
+
+        with self.subTest(f"Assert sorting {table_class.__name__} on '-{field_name}'"):
+            table = table_class(queryset.with_tree_fields(), order_by=f"-{field_name}")
+            table_queryset_data = table.data.data.values_list(field_name, flat=True)
+            sorted_queryset = (
+                queryset.with_tree_fields().extra(order_by=[f"-{field_name}"]).values_list(field_name, flat=True)
+            )
             self.assertEqual(list(table_queryset_data), list(sorted_queryset))
 
     def test_tree_model_table_orderable(self):
@@ -61,14 +71,41 @@ class TableTestCase(TestCase):
             table_avail_fields = set(model_field_names) & set(table_class.Meta.fields)
             for table_field_name in table_avail_fields:
                 self._validate_sorted_tree_queryset_same_with_table_queryset(queryset, table_class, table_field_name)
-                self._validate_sorted_tree_queryset_same_with_table_queryset(
-                    queryset, table_class, f"-{table_field_name}"
-                )
 
         # Test for `rack_count`
         queryset = RackGroupTable.Meta.model.objects.annotate(rack_count=count_related(Rack, "rack_group")).all()
         self._validate_sorted_tree_queryset_same_with_table_queryset(queryset, RackGroupTable, "rack_count")
-        self._validate_sorted_tree_queryset_same_with_table_queryset(queryset, RackGroupTable, "-rack_count")
+
+        # https://github.com/nautobot/nautobot/issues/7330 - sorting by custom field
+        l1 = Location.objects.first()
+        l1._custom_field_data["example_app_auto_custom_field"] = "alpha"
+        l1.validated_save()
+        l2 = Location.objects.last()
+        l2._custom_field_data["example_app_auto_custom_field"] = "omega"
+        l2.validated_save()
+        table = LocationTable(
+            Location.objects.exclude(_custom_field_data__example_app_auto_custom_field="Default value")
+        )
+
+        table.order_by = ["cf_example_app_auto_custom_field"]
+        table_queryset_data = table.data.data.values_list("pk", flat=True)
+        sorted_queryset = (
+            Location.objects.with_tree_fields()
+            .exclude(_custom_field_data__example_app_auto_custom_field="Default value")
+            .extra(order_by=["_custom_field_data__example_app_auto_custom_field"])
+            .values_list("pk", flat=True)
+        )
+        self.assertEqual(list(table_queryset_data), list(sorted_queryset))
+
+        table.order_by = ["-cf_example_app_auto_custom_field"]
+        table_queryset_data = table.data.data.values_list("pk", flat=True)
+        sorted_queryset = (
+            Location.objects.with_tree_fields()
+            .exclude(_custom_field_data__example_app_auto_custom_field="Default value")
+            .extra(order_by=["-_custom_field_data__example_app_auto_custom_field"])
+            .values_list("pk", flat=True)
+        )
+        self.assertEqual(list(table_queryset_data), list(sorted_queryset))
 
     def test_base_table_apis(self):
         """