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

nautobot/apps/views.py

@@ -30,6 +30,7 @@ from nautobot.core.views.mixins import (
     ObjectListViewMixin,
     ObjectNotesViewMixin,
     ObjectPermissionRequiredMixin,
+    UIComponentsMixin,
 )
 from nautobot.core.views.paginator import EnhancedPage, EnhancedPaginator, get_paginate_count
 from nautobot.core.views.renderers import NautobotHTMLRenderer
@@ -78,6 +79,7 @@ __all__ = (
     "ObjectNotesViewMixin",
     "ObjectPermissionRequiredMixin",
     "ObjectView",
+    "UIComponentsMixin",
     "check_and_call_git_repository_function",
     "check_filter_for_display",
     "csv_format",

nautobot/circuits/templates/circuits/circuittermination_retrieve.html

@@ -1,9 +1,2 @@
 {% extends 'generic/object_retrieve.html' %}
-{% load helpers %}
-
-{% block breadcrumbs %}
-    <li><a href="{% url 'circuits:circuit_list' %}">Circuits</a></li>
-    <li><a href="{% url 'circuits:circuit_list' %}?provider={{ object.circuit.provider.pk }}">{{ object.circuit.provider }}</a></li>
-    <li>{{ object.circuit|hyperlinked_object }}</li>
-    <li>{{ object|hyperlinked_object }}</li>
-{% endblock breadcrumbs %}
+{% comment %}3.0 TODO: remove this template, which only exists for backward compatibility with 2.4 and earlier{% endcomment %}

nautobot/circuits/templates/circuits/inc/circuit_termination_speed_fragment.html

@@ -0,0 +1,9 @@
+{% spaceless %}
+{% load helpers %}
+{% if termination.port_speed and termination.upstream_speed %}
+<i class="mdi mdi-arrow-down-bold" title="Downstream"></i>{{ termination.port_speed|humanize_speed }}&nbsp;
+<i class="mdi mdi-arrow-up-bold" title="Upstream"></i>{{ termination.upstream_speed|humanize_speed }}
+{% else %}
+{{ termination.port_speed|humanize_speed|placeholder }}
+{% endif %}
+{% endspaceless %}

nautobot/circuits/tests/integration/test_circuit.py

@@ -128,8 +128,8 @@ class CircuitTestCase(SeleniumTestCase, ObjectsListMixin, ObjectDetailsMixin):
                 # Assert that value are properly set
                 panel_label = f"Termination - {side} Side"
                 self.assertPanelValue(panel_label, "Location", self.location.name)
-                self.assertPanelValue(panel_label, "Port Speed (Kbps)", port_speed)
-                self.assertPanelValue(panel_label, "Upstream Speed (Kbps)", upstream_speed)
+                self.assertPanelValue(panel_label, "Speed", port_speed)
+                self.assertPanelValue(panel_label, "Speed", upstream_speed)
                 self.assertPanelValue(panel_label, "Cross-connect ID", xconnect_id)
                 self.assertPanelValue(panel_label, "Patch Panel/port(s)", pp_info)
                 self.assertPanelValue(panel_label, "Description", description)

nautobot/circuits/views.py

@@ -5,6 +5,7 @@ from django.utils.html import format_html, format_html_join
 
 from nautobot.core.forms import ConfirmationForm
 from nautobot.core.templatetags import helpers
+from nautobot.core.ui.breadcrumbs import Breadcrumbs, InstanceBreadcrumbItem, ModelBreadcrumbItem
 from nautobot.core.ui.choices import SectionChoices
 from nautobot.core.ui.object_detail import (
     ObjectDetailContent,
@@ -58,6 +59,10 @@ class CircuitTerminationObjectFieldsPanel(ObjectFieldsPanel):
     def render_key(self, key, value, context):
         if key == "connected_endpoint":
             return "IP Addressing"
+
+        if key == "port_speed":
+            return "Speed"
+
         return super().render_key(key, value, context)
 
     def render_value(self, key, value, context):
@@ -80,6 +85,10 @@ class CircuitTerminationObjectFieldsPanel(ObjectFieldsPanel):
                 "{} ({})",
                 ((helpers.hyperlinked_object(ip), getattr(ip, "vrf", None) or "Global") for ip in ip_addresses.all()),
             )
+
+        if key == "port_speed":
+            return render_component_template("circuits/inc/circuit_termination_speed_fragment.html", context)
+
         return super().render_value(key, value, context)
 
 
@@ -93,6 +102,20 @@ class CircuitTerminationUIViewSet(NautobotUIViewSet):
     serializer_class = serializers.CircuitTerminationSerializer
     table_class = tables.CircuitTerminationTable
 
+    breadcrumbs = Breadcrumbs(
+        items={
+            "detail": [
+                ModelBreadcrumbItem(model=Circuit),
+                ModelBreadcrumbItem(
+                    model=Circuit,
+                    label=lambda c: c["object"].circuit.provider,
+                    reverse_query_params=lambda c: {"provider": c["object"].circuit.provider.pk},
+                ),
+                InstanceBreadcrumbItem(instance=lambda c: c["object"].circuit),
+            ]
+        }
+    )
+
     object_detail_content = ObjectDetailContent(
         panels=(
             CircuitTerminationObjectFieldsPanel(
@@ -104,7 +127,6 @@ class CircuitTerminationUIViewSet(NautobotUIViewSet):
                     "cloud_network",
                     "cable",
                     "port_speed",
-                    "upstream_speed",
                     "connected_endpoint",
                     "xconnect_id",
                     "pp_info",
@@ -115,15 +137,7 @@ class CircuitTerminationUIViewSet(NautobotUIViewSet):
                     "provider_network",
                     "cloud_network",
                     "port_speed",
-                    "upstream_speed",
-                ],
-                exclude_fields=[
-                    "circuit",
                 ],
-                value_transforms={
-                    "port_speed": [helpers.humanize_speed],
-                    "upstream_speed": [helpers.humanize_speed],
-                },
             ),
         )
     )
@@ -188,17 +202,12 @@ class CircuitUIViewSet(NautobotUIViewSet):
                     "provider_network",
                     "cloud_network",
                     "port_speed",
-                    "upstream_speed",
                     "ip_addresses",
                     "xconnect_id",
                     "pp_info",
                     "description",
                 ),
-                value_transforms={
-                    "port_speed": [helpers.humanize_speed, helpers.placeholder],
-                    "upstream_speed": [helpers.humanize_speed],
-                },
-                hide_if_unset=("location", "provider_network", "cloud_network", "upstream_speed"),
+                hide_if_unset=("location", "provider_network", "cloud_network"),
                 ignore_nonexistent_fields=True,  # ip_addresses may be undefined
                 header_extra_content_template_path="circuits/inc/circuit_termination_header_extra_content.html",
                 **kwargs,
@@ -245,6 +254,10 @@ class CircuitUIViewSet(NautobotUIViewSet):
                 )
             if key == "ip_addresses":
                 return "IP Addressing"
+
+            if key == "port_speed":
+                return "Speed"
+
             return super().render_key(key, value, context)
 
         def render_value(self, key, value, context):
@@ -257,6 +270,10 @@ class CircuitUIViewSet(NautobotUIViewSet):
                 if not context["termination"].location:
                     return ""
                 return render_component_template("circuits/inc/circuit_termination_cable_fragment.html", context)
+
+            if key == "port_speed":
+                return render_component_template("circuits/inc/circuit_termination_speed_fragment.html", context)
+
             return super().render_value(key, value, context)
 
         def queryset_list_url_filter(self, key, value, context):

nautobot/core/filters.py

@@ -175,7 +175,7 @@ class RelatedMembershipBooleanFilter(django_filters.BooleanFilter):
         )
 
     def filter(self, qs, value):
-        if value in EMPTY_VALUES:
+        if value in EMPTY_VALUES or (hasattr(value, "exists") and not value.exists()):
             return qs
         if self.distinct:
             qs = qs.distinct()
@@ -542,7 +542,7 @@ class TreeNodeMultipleChoiceFilter(NaturalKeyOrPKMultipleChoiceFilter):
         return query
 
     def filter(self, qs, value):
-        if value in EMPTY_VALUES:
+        if value in EMPTY_VALUES or (hasattr(value, "exists") and not value.exists()):
             return qs
 
         # Fetch the generated Q object and filter the incoming qs with it before passing it along.

nautobot/core/settings.py

@@ -157,6 +157,7 @@ METRICS_AUTHENTICATED = is_truthy(os.getenv("NAUTOBOT_METRICS_AUTHENTICATED", "F
 METRICS_DISABLED_APPS = []
 if "NAUTOBOT_METRICS_DISABLED_APPS" in os.environ and os.environ["NAUTOBOT_METRICS_DISABLED_APPS"] != "":
     METRICS_DISABLED_APPS = os.getenv("NAUTOBOT_METRICS_DISABLED_APPS", "").split(_CONFIG_SETTING_SEPARATOR)
+METRICS_EXPERIMENTAL_CACHING_DURATION = int(os.getenv("NAUTOBOT_METRICS_EXPERIMENTAL_CACHING_DURATION", "0"))
 
 # Napalm
 NAPALM_ARGS = {}

nautobot/core/settings.yaml

@@ -1377,6 +1377,15 @@ properties:
     see_also:
       "Guide to Nautobot Prometheus metrics": "../guides/prometheus-metrics.md"
     type: "boolean"
+  METRICS_EXPERIMENTAL_CACHING_DURATION:
+    default: 0
+    description: >-
+      The number of seconds to cache Nautobot App metrics before refreshing them.
+      A value of `0` means no caching (i.e. always recompute metrics on each request). This feature is experimental
+      and may change or be removed in a future release, including patch releases.
+    environment_variable: "NAUTOBOT_METRICS_EXPERIMENTAL_CACHING_DURATION"
+    type: "integer"
+    version_added: "2.4.18"
   NAPALM_ARGS:
     additionalProperties: true
     default: {}

nautobot/core/tables.py

@@ -17,7 +17,6 @@ import django_tables2
 from django_tables2.data import TableData, TableQuerysetData
 from django_tables2.rows import BoundRows
 from django_tables2.utils import Accessor, OrderBy, OrderByTuple
-from tree_queries.models import TreeNode
 
 from nautobot.core.models.querysets import count_related
 from nautobot.core.templatetags import helpers
@@ -107,6 +106,12 @@ class BaseTable(django_tables2.Table):
         if order_by is None and saved_view is not None:
             order_by = saved_view.config.get("sort_order", None)
 
+        # Don't show hierarchy if we're sorted
+        if order_by is not None and hide_hierarchy_ui is None:
+            hide_hierarchy_ui = True
+
+        self.hide_hierarchy_ui = hide_hierarchy_ui
+
         # Init table
         super().__init__(*args, order_by=order_by, **kwargs)
 
@@ -118,12 +123,6 @@ class BaseTable(django_tables2.Table):
                 *[column.name for column in self.columns if isinstance(column.column, LinkedCountColumn)],
             ]
 
-        # Don't show hierarchy if we're sorted
-        if order_by is not None and hide_hierarchy_ui is None:
-            hide_hierarchy_ui = True
-
-        self.hide_hierarchy_ui = hide_hierarchy_ui
-
         # Set default empty_text if none was provided
         if self.empty_text is None:
             self.empty_text = f"No {self._meta.model._meta.verbose_name_plural} found"
@@ -304,6 +303,10 @@ class BaseTable(django_tables2.Table):
         Arguments:
             value: iterable or comma separated string of order by aliases.
         """
+        # The below block of code is copied from Table.order_by()
+        # due to limitations in directly calling parent class methods within a property setter.
+        # See Python bug report: https://bugs.python.org/issue14965
+
         # collapse empty values to ()
         order_by = () if not value else value
         # accept string
@@ -316,22 +319,17 @@ class BaseTable(django_tables2.Table):
                 valid.append(alias)
         self._order_by = OrderByTuple(valid)
 
-        # The above block of code is copied from super().order_by
-        # due to limitations in directly calling parent class methods within a property setter.
-        # See Python bug report: https://bugs.python.org/issue14965
-        model = getattr(self.Meta, "model", None)
-        if model and issubclass(model, TreeNode):
-            # Use the TreeNode model's approach to sorting
-            queryset = self.data.data
-            # If the data passed into the Table is a list (as in cases like BulkImport post),
-            # convert this list to a queryset.
-            # This ensures consistent behavior regardless of the input type.
-            if isinstance(self.data.data, list):
-                queryset = model.objects.filter(pk__in=[instance.pk for instance in self.data.data])
-            self.data.data = queryset.extra(order_by=self._order_by)
-        else:
-            # Otherwise, use the default sorting method
-            self.data.order_by(self._order_by)
+        # Nautobot-specific logic begins here
+        if self._order_by:
+            self.hide_hierarchy_ui = True
+            if isinstance(self.data.data, QuerySet) and hasattr(self.data.data, "without_tree_fields"):
+                self.data.data = self.data.data.without_tree_fields()
+        elif not self.hide_hierarchy_ui:
+            if isinstance(self.data.data, QuerySet) and hasattr(self.data.data, "with_tree_fields"):
+                self.data.data = self.data.data.with_tree_fields()
+
+        # Resume base class implementation
+        self.data.order_by(self._order_by)
 
     def add_conditional_prefetch(self, table_field, db_column=None, prefetch=None):
         """Conditionally prefetch the specified database column if the related table field is visible.

nautobot/core/templates/components/breadcrumbs.html

@@ -0,0 +1,19 @@
+{% load helpers %}
+
+<ol class="breadcrumb">
+    {% block breadcrumbs %}
+        {% if legacy_breadcrumbs %}
+            {{ legacy_breadcrumbs | safe }}
+        {% else %}
+            {% for url, title in breadcrumbs_items %}
+                <li>
+                {% if url %}
+                    <a href="{{ url }}">{{ title }}</a>
+                {% else %}
+                    {{ title }}
+                {% endif %}
+                </li>
+            {% endfor %}
+        {% endif %}
+    {% endblock %}
+</ol>

nautobot/core/templates/generic/object_changelog.html

@@ -1,7 +1,5 @@
 {% extends base_template %}
 
-{% block title %}{{ block.super }} - Change Log{% endblock %}
-
 {% block content %}
     {% include 'panel_table.html' %}
     {% include 'inc/paginator.html' with paginator=table.paginator page=table.page %}

nautobot/core/templates/generic/object_list.html

@@ -11,19 +11,22 @@
 {% block header %}
     <div class="row noprint">
         <div class="{% if search_form %}col-sm-8 col-md-9 {% else %} col-md-12 {% endif %}">
-            {% if breadcrumbs is not None %}
-                {% render_breadcrumbs %}
-            {% else %}
-                {# TODO: remove this fragment after breadcrumbs implementation in generic views like ConsoleConnectionsListView #}
-                <ol class="breadcrumb">
-                    {% block breadcrumbs %}
-                        {% if list_url %}
-                            <li><a href="{% url list_url %}">{{ title }}</a></li>
-                        {% endif %}
-                        {% block extra_breadcrumbs %}{% endblock extra_breadcrumbs %}
-                    {% endblock breadcrumbs %}
-                </ol>
+        {% captureas default_breadcrumbs %}
+            {% if list_url %}
+                <li><a href="{% url list_url %}">{{ title }}</a></li>
             {% endif %}
+        {% endcaptureas %}
+
+        {% captureas block_breadcrumbs %}
+            {% block breadcrumbs %}
+                {% if list_url %}
+                    <li><a href="{% url list_url %}">{{ title }}</a></li>
+                {% endif %}
+                {% block extra_breadcrumbs %}{% endblock extra_breadcrumbs %}
+            {% endblock breadcrumbs %}
+        {% endcaptureas %}
+
+        {% render_breadcrumbs default_breadcrumbs block_breadcrumbs %}
         </div>
         {% if search_form %}
         <div class="col-sm-4 col-md-3">

nautobot/core/templates/generic/object_notes.html

@@ -2,8 +2,6 @@
 {% load helpers %}
 {% load form_helpers %}
 
-{% block title %}{{ block.super }} - Notes{% endblock %}
-
 {% block content %}
     {% if perms.extras.add_note %}
         <form action="{% url 'extras:note_add' %}?return_url={{ request.path }}?tab=notes" method="post" enctype="multipart/form-data" class="form form-horizontal">

nautobot/core/templates/generic/object_retrieve.html

@@ -14,17 +14,24 @@
     <div class="row noprint">
         {% with list_url=object|validated_viewname:"list" %}
         <div class="col-sm-8 col-md-9">
-            <ol class="breadcrumb">
+        {% captureas default_breadcrumbs %}
+            {% with list_url=object|validated_viewname:"list" %}
+                <li><a href="{% url list_url %}">{{ verbose_name_plural|bettertitle }}</a></li>
+            {% endwith %}
+            <li>{{ object|hyperlinked_object }}</li>
+        {% endcaptureas %}
+
+        {% captureas block_breadcrumbs %}
             {% block breadcrumbs %}
-                {% if list_url %}
-                <li><a href="{% url list_url %}">
-                    {{ verbose_name_plural|bettertitle }}
-                </a></li>
-                {% endif %}
+                {% with list_url=object|validated_viewname:"list" %}
+                    <li><a href="{% url list_url %}">{{ verbose_name_plural|bettertitle }}</a></li>
+                {% endwith %}
                 {% block extra_breadcrumbs %}{% endblock extra_breadcrumbs %}
                 <li>{{ object|hyperlinked_object }}</li>
-            {% endblock breadcrumbs %}
-            </ol>
+            {% endblock %}
+        {% endcaptureas %}
+
+        {% render_breadcrumbs default_breadcrumbs block_breadcrumbs %}
         </div>
         {% if list_url %}
         <div class="col-sm-4 col-md-3">
@@ -55,7 +62,7 @@
     {% block masthead %}
         <h1>
             <span class="hover_copy">
-                <span id="copy_title">{% block title %}{{object.display|default:object}}{% endblock %}</span>
+                <span id="copy_title">{% block title %}{% render_title %}{% endblock %}</span>
                 <button type="button" class="btn btn-inline btn-default hover_copy_button" data-clipboard-text="{{ object.display | default:object }}">
                     <span class="mdi mdi-content-copy"></span>
                 </button>

nautobot/core/templatetags/helpers.py

@@ -1352,3 +1352,27 @@ def saved_view_title(context, mode: Literal["html", "plain"] = "html"):
         return strip_tags(title)
 
     return title
+
+
+# https://www.djangosnippets.org/snippets/545/
+@register.tag(name="captureas")
+def do_captureas(parser, token):
+    try:
+        _, args = token.contents.split(None, 1)
+    except ValueError:
+        raise template.TemplateSyntaxError("'captureas' node requires a variable name.")
+    nodelist = parser.parse(("endcaptureas",))
+    parser.delete_first_token()
+    return CaptureasNode(nodelist, args)
+
+
+class CaptureasNode(template.Node):
+    def __init__(self, nodelist, varname):
+        self.nodelist = nodelist
+        self.varname = varname
+
+    def render(self, context):
+        output = self.nodelist.render(context)
+        output = output.strip()
+        context[self.varname] = output
+        return ""

nautobot/core/templatetags/ui_framework.py

@@ -1,10 +1,12 @@
+from functools import partial
 import logging
 
 from django import template
-from django.utils.html import format_html_join
+from django.utils.html import format_html_join, strip_spaces_between_tags
 
 from nautobot.core.ui.breadcrumbs import Breadcrumbs
 from nautobot.core.ui.titles import Titles
+from nautobot.core.ui.utils import render_component_template
 from nautobot.core.utils.lookup import get_view_for_model
 from nautobot.core.views.utils import get_obj_from_context
 
@@ -31,21 +33,54 @@ def render_components(context, components):
 
 @register.simple_tag(takes_context=True)
 def render_title(context, mode="plain"):
+    """
+    Render the title passed in the context. Due to backwards compatibility in most of the Generic views,
+    we're either passing `title` to the template or render `title` defined in `view_titles`.
+
+    But in some newer views we want to have simple way to render title, only by defining `view_titles` within a view class.
+    """
+    if title := context.get("title"):
+        return title
+
     title_obj = context.get("view_titles")
     if title_obj is not None and isinstance(title_obj, Titles):
         return title_obj.render(context, mode=mode)
 
-    if fallback_title := context.get("title"):
-        return fallback_title
     return ""
 
 
 @register.simple_tag(takes_context=True)
-def render_breadcrumbs(context):
+def render_breadcrumbs(context, legacy_default_breadcrumbs=None, legacy_block_breadcrumbs=None):
+    """
+    Renders the breadcrumbs using the UI Component Framework or legacy template-defined breadcrumbs.
+
+    Function checks if breadcrumbs from UI Component Framework are available and render them but only
+    when there is no other changes coming from legacy template-defined breadcrumbs.
+
+    Examples:
+    - UI Component Framework breadcrumbs are defined in the view. But in the template, {% block breadcrumbs %} is being used,
+    to override breadcrumbs or `{% block extra_breadcrumbs %}`. Output: template breadcrumbs will be rendered.
+    - There is no UI Component Framework breadcrumbs and no other block overrides. Output: default breadcrumbs will be rendered.
+    - UI Component Framework breadcrumbs are defined in the view. No breadcrumbs block overrides. Output: UI Component Framework breadcrumbs will be rendered.
+    """
+    render_template = partial(
+        render_component_template,
+        "components/breadcrumbs.html",
+        context,
+    )
+
+    if (
+        legacy_block_breadcrumbs
+        and strip_spaces_between_tags(legacy_default_breadcrumbs).strip()
+        != strip_spaces_between_tags(legacy_block_breadcrumbs).strip()
+    ):
+        return render_template(legacy_breadcrumbs=legacy_block_breadcrumbs)
+
     breadcrumbs_obj = context.get("breadcrumbs")
     if breadcrumbs_obj is not None and isinstance(breadcrumbs_obj, Breadcrumbs):
         return breadcrumbs_obj.render(context)
-    return ""
+
+    return render_template(legacy_breadcrumbs=legacy_default_breadcrumbs)
 
 
 @register.simple_tag(takes_context=True)

nautobot/core/testing/filters.py

@@ -99,6 +99,17 @@ class FilterTestCases:
             self.assertIsNotNone(self.filterset)
             return self.filterset.declared_filters["q"].filter_predicates
 
+        def test_no_distinct_on_empty_filter_params(self):
+            """Verify that an empty filterset doesn't cause a `SELECT DISTINCT`."""
+            self.assertIsNotNone(self.filterset)
+            filterset = self.filterset({}, self.queryset)  # pylint: disable=not-callable  # see assertion above
+            self.assertTrue(filterset.is_valid())
+            self.assertNotIn(
+                "SELECT DISTINCT",
+                str(filterset.qs.query),
+                "Filter set with empty parameter added `DISTINCT` to select query. This needs to be avoided because it incurs heavy performance penalties.",
+            )
+
         def test_id(self):
             """Verify that the filterset supports filtering by id with only lookup `__n`."""
             self.assertIsNotNone(self.filterset)
@@ -326,29 +337,34 @@ class FilterTestCases:
             if not isinstance(obj_field, (CharField, TextField)):
                 self.skipTest("Not a CharField or TextField")
 
+            original_value = getattr(obj, obj_field_name)
             # Create random lowercase string to use for icontains lookup
             max_length = obj_field.max_length or CHARFIELD_MAX_LENGTH
             randomized_attr_value = "".join(random.choices(string.ascii_lowercase, k=max_length))  # noqa: S311 # pseudo-random generator
-            setattr(obj, obj_field_name, randomized_attr_value)
-            obj.save()
-
-            # if lookup_method is iexact use the full updated attr
-            if lookup_method == "iexact":
-                lookup = randomized_attr_value.upper()
-                model_queryset = self.queryset.filter(**{f"{filter_field_name}__iexact": lookup})
-            else:
-                lookup = randomized_attr_value[1:].upper()
-                model_queryset = self.queryset.filter(**{f"{filter_field_name}__icontains": lookup})
-            params = {"q": lookup}
-            filterset_result = self.filterset(params, self.queryset)  # pylint: disable=not-callable
-
-            self.assertTrue(filterset_result.is_valid())
-            self.assertQuerysetEqualAndNotEmpty(
-                filterset_result.qs,
-                model_queryset,
-                ordered=False,
-                msg=lookup,
-            )
+            try:
+                setattr(obj, obj_field_name, randomized_attr_value)
+                obj.save()
+
+                # if lookup_method is iexact use the full updated attr
+                if lookup_method == "iexact":
+                    lookup = randomized_attr_value.upper()
+                    model_queryset = self.queryset.filter(**{f"{filter_field_name}__iexact": lookup})
+                else:
+                    lookup = randomized_attr_value[1:].upper()
+                    model_queryset = self.queryset.filter(**{f"{filter_field_name}__icontains": lookup})
+                params = {"q": lookup}
+                filterset_result = self.filterset(params, self.queryset)  # pylint: disable=not-callable
+
+                self.assertTrue(filterset_result.is_valid())
+                self.assertQuerysetEqualAndNotEmpty(
+                    filterset_result.qs,
+                    model_queryset,
+                    ordered=False,
+                    msg=lookup,
+                )
+            finally:
+                setattr(obj, obj_field_name, original_value)
+                obj.save()
 
         def _get_relevant_filterset_queryset(self, queryset, *filter_params):
             """Gets the relevant queryset based on filter parameters."""
@@ -454,7 +470,7 @@ class FilterTestCases:
             tenant_groups = list(
                 models.TenantGroup.objects.filter(
                     tenants__isnull=False, **{f"tenants__{self.tenancy_related_name}__isnull": False}
-                )
+                ).distinct()
             )[:2]
             tenant_groups_including_children = []
             for tenant_group in tenant_groups:

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
@@ -776,6 +777,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