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

nautobot/core/templatetags/helpers.py

@@ -1,3 +1,4 @@
+from collections.abc import Iterable
 import datetime
 import json
 import logging
@@ -23,7 +24,7 @@ import yaml
 from nautobot.apps.config import get_app_settings_or_config
 from nautobot.core import forms
 from nautobot.core.constants import PAGINATE_COUNT_DEFAULT
-from nautobot.core.utils import color, config, data, logging as nautobot_logging, lookup
+from nautobot.core.utils import color, config, data, deprecation, logging as nautobot_logging, lookup
 from nautobot.core.utils.requests import add_nautobot_version_query_param_to_url
 
 HTML_TRUE = mark_safe('<span class="text-success"><i class="mdi mdi-check-bold" title="Yes"></i></span>')
@@ -762,6 +763,23 @@ def render_address(address):
     return HTML_NONE
 
 
+@register.filter()
+def render_m2m(queryset, full_listing_link, verbose_name_plural, max_visible=5):
+    total_count = queryset.count()
+    display_count = min(total_count, max_visible)
+    if not display_count:
+        return HTML_NONE
+
+    items = [hyperlinked_object(record) for record in queryset[:display_count]]
+
+    remaining = total_count - display_count
+    if remaining > 0:
+        link = format_html('<a href="{}">... View {} more {}</a>', full_listing_link, remaining, verbose_name_plural)
+        items.append(link)
+
+    return format_html_join("", "<div>{}</div>", ((item,) for item in items)) if items else HTML_NONE
+
+
 @library.filter()
 @register.filter()
 def render_button_class(value):
@@ -823,11 +841,7 @@ def get_attr(obj, attr, default=None):
     return getattr(obj, attr, default)
 
 
-@register.simple_tag()
-def querystring(request, **kwargs):
-    """
-    Append or update the page number in a querystring.
-    """
+def _base_querystring(request, **kwargs):
     querydict = request.GET.copy()
     for k, v in kwargs.items():
         if v is not None:
@@ -841,6 +855,66 @@ def querystring(request, **kwargs):
         return ""
 
 
+# TODO: Remove this tag in Nautobot 3.0.
+
+
+@register.simple_tag()
+@deprecation.method_deprecated(
+    "Leverage `legacy_querystring` instead of `querystring` if this templatetag is required. In Nautobot 3.0, "
+    "`querystring` will be removed in preparation for Django 5.2 in which there is a built-in querystring tag "
+    "that operates differently. You may find that `django_querystring` is more appropriate for your use case "
+    "and is a replica of Django 5.2's `querystring` templatetag."
+)
+def querystring(request, **kwargs):
+    return _base_querystring(request, **kwargs)
+
+
+@register.simple_tag()
+def legacy_querystring(request, **kwargs):
+    return _base_querystring(request, **kwargs)
+
+
+# Note: This is vendored from Django 5.2
+@register.simple_tag(name="django_querystring", takes_context=True)
+def django_querystring(context, query_dict=None, **kwargs):
+    """
+    Add, remove, and change parameters of a ``QueryDict`` and return the result
+    as a query string. If the ``query_dict`` argument is not provided, default
+    to ``request.GET``.
+
+    For example::
+
+        {% django_querystring foo=3 %}
+
+    To remove a key::
+
+        {% django_querystring foo=None %}
+
+    To use with pagination::
+
+        {% django_querystring page=page_obj.next_page_number %}
+
+    A custom ``QueryDict`` can also be used::
+
+        {% django_querystring my_query_dict foo=3 %}
+    """
+    if query_dict is None:
+        query_dict = context.request.GET
+    params = query_dict.copy()
+    for key, value in kwargs.items():
+        if value is None:
+            if key in params:
+                del params[key]
+        elif isinstance(value, Iterable) and not isinstance(value, str):
+            params.setlist(key, value)
+        else:
+            params[key] = value
+    if not params and not query_dict:
+        return ""
+    query_string = params.urlencode()
+    return f"?{query_string}"
+
+
 @register.simple_tag()
 def table_config_button(table, table_name=None, extra_classes="", disabled=False):
     if table_name is None:
@@ -1278,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/mixins.py

@@ -156,7 +156,7 @@ class NautobotTestCaseMixin:
         """
         for name in names:
             ct, action = permissions.resolve_permission_ct(name)
-            obj_perm = users_models.ObjectPermission(name=name, actions=[action], **kwargs)
+            obj_perm, _ = users_models.ObjectPermission.objects.get_or_create(name=name, actions=[action], **kwargs)
             obj_perm.save()
             obj_perm.users.add(self.user)
             obj_perm.object_types.add(ct)

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
@@ -281,8 +282,7 @@ class ViewTestCases:
             if getattr(obj, "is_contact_associable_model", False):
                 self.assertBodyContains(
                     response,
-                    f'<a href="{obj.get_absolute_url()}#contacts" onclick="switch_tab(this.href)" aria-controls="contacts" role="tab" data-toggle="tab">Contacts</a>',
-                    html=True,
+                    f'href="{obj.get_absolute_url()}#contacts" onclick="switch_tab(this.href)"',
                 )
             else:
                 self.assertNotContains(response, f"{obj.get_absolute_url()}#contacts")
@@ -304,8 +304,7 @@ class ViewTestCases:
                 if getattr(obj, "is_contact_associable_model", False):
                     self.assertBodyContains(
                         response,
-                        f'<a href="{obj.get_absolute_url()}#contacts" onclick="switch_tab(this.href)" aria-controls="contacts" role="tab" data-toggle="tab">Contacts</a>',
-                        html=True,
+                        f'href="{obj.get_absolute_url()}#contacts" onclick="switch_tab(this.href)"',
                     )
                 else:
                     self.assertNotContains(response, f"{obj.get_absolute_url()}#contacts")
@@ -778,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

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):
         """

nautobot/core/tests/test_templatetags_ui_framework.py

@@ -0,0 +1,146 @@
+from django.template import Context
+
+from nautobot.core.templatetags import ui_framework
+from nautobot.core.testing import TestCase
+from nautobot.core.ui.breadcrumbs import Breadcrumbs
+from nautobot.core.ui.titles import Titles
+
+
+class NautobotTemplatetagsUIComponentsTest(TestCase):
+    """Tests template tags from ui_framework module."""
+
+    # ---------------------------
+    # render_title
+    # ---------------------------
+
+    def test_render_title_with_legacy_title_present(self):
+        context = Context(
+            {
+                "title": "Custom Title",
+                "view_titles": Titles(),
+                "verbose_name_plural": "Default Title",
+            }
+        )
+        output = ui_framework.render_title(context)
+
+        self.assertEqual(output, "Custom Title")
+
+    def test_render_title_with_view_titles_only(self):
+        context = Context(
+            {
+                "view_titles": Titles(),
+                "verbose_name_plural": "Default Title",
+            }
+        )
+        output = ui_framework.render_title(context)
+
+        self.assertEqual(output, "Default Title")
+
+    def test_render_title_with_invalid_view_titles(self):
+        class MyStuff:
+            pass
+
+        context = Context(
+            {
+                "view_titles": MyStuff(),
+                "verbose_name_plural": "Default Title",
+            }
+        )
+        output = ui_framework.render_title(context)
+
+        self.assertEqual(output, "")
+
+    def test_render_title_with_empty_context(self):
+        context = Context({})
+        output = ui_framework.render_title(context)
+
+        self.assertEqual(output, "")
+
+    # ---------------------------
+    # render_breadcrumbs
+    # ---------------------------
+
+    def test_render_breadcrumbs(self):
+        context = Context(
+            {
+                "list_url": "home",
+                "title": "New Home",
+                "view_action": "list",
+                "breadcrumbs": Breadcrumbs(),
+            }
+        )
+        output = ui_framework.render_breadcrumbs(context)
+
+        self.assertHTMLEqual(output, '<ol class="breadcrumb"><li><a href="/">New Home</a></li></ol>')
+
+    def test_render_breadcrumbs_empty_context(self):
+        context = Context({})
+        output = ui_framework.render_breadcrumbs(context)
+
+        self.assertHTMLEqual(output, '<ol class="breadcrumb"></ol>')
+
+    def test_render_breadcrumbs_with_legacy_breadcrumbs(self):
+        legacy_breadcrumbs = '<li><a href="/">Home</a></li>'
+        context = Context({})
+        output = ui_framework.render_breadcrumbs(context, legacy_breadcrumbs)
+
+        self.assertHTMLEqual(output, '<ol class="breadcrumb"><li><a href="/">Home</a></li></ol>')
+
+    def test_render_breadcrumbs_with_legacy_and_block_breadcrumbs_the_same_with_breadcrumbs_class(self):
+        legacy_breadcrumbs = block_breadcrumbs = '<li><a href="/">Home</a></li>'
+        context = Context(
+            {
+                "list_url": "home",
+                "title": "New Home",
+                "view_action": "list",
+                "breadcrumbs": Breadcrumbs(),
+            }
+        )
+        output = ui_framework.render_breadcrumbs(context, legacy_breadcrumbs, block_breadcrumbs)
+
+        self.assertHTMLEqual(output, '<ol class="breadcrumb"><li><a href="/">New Home</a></li></ol>')
+
+    def test_render_breadcrumbs_with_legacy_and_block_breadcrumbs_the_same_and_no_breadcrumbs_class(self):
+        legacy_breadcrumbs = block_breadcrumbs = '<li><a href="/">Home</a></li>'
+        context = Context({})
+        output = ui_framework.render_breadcrumbs(context, legacy_breadcrumbs, block_breadcrumbs)
+
+        self.assertHTMLEqual(output, '<ol class="breadcrumb"><li><a href="/">Home</a></li></ol>')
+
+    def test_render_breadcrumbs_with_legacy_breadcrumbs_override(self):
+        legacy_breadcrumbs = '<li><a href="/">Home</a></li>'
+        block_breadcrumbs = '<li><a href="/">Override</a></li>'
+        context = Context(
+            {
+                "list_url": "home",
+                "title": "New Home",
+                "view_action": "list",
+                "breadcrumbs": Breadcrumbs(),
+            }
+        )
+        output = ui_framework.render_breadcrumbs(context, legacy_breadcrumbs, block_breadcrumbs)
+
+        self.assertHTMLEqual(output, '<ol class="breadcrumb"><li><a href="/">Override</a></li></ol>')
+
+    def test_render_breadcrumbs_strips_tags(self):
+        legacy_breadcrumbs = """
+        <li>
+            <a href="/">Home</a>
+        </li>"""
+
+        block_breadcrumbs = """<li>
+
+            <a href="/">Home</a></li>
+        """
+
+        context = Context(
+            {
+                "list_url": "home",
+                "title": "New Home",
+                "view_action": "list",
+                "breadcrumbs": Breadcrumbs(),
+            }
+        )
+        output = ui_framework.render_breadcrumbs(context, legacy_breadcrumbs, block_breadcrumbs)
+
+        self.assertHTMLEqual(output, '<ol class="breadcrumb"><li><a href="/">New Home</a></li></ol>')

nautobot/core/tests/test_titles.py

@@ -163,7 +163,7 @@ class TitlesTestCase(TestCase):
         """Test rendering when no view_action is provided."""
         context = Context({"verbose_name_plural": "devices"})
         result = self.titles.render(context)
-        self.assertEqual(result, "Devices")  # Should use list_action as default
+        self.assertEqual(result, "Devices")  # Should use * action as default
 
     def test_get_extra_context(self):
         """Test that get_extra_context returns empty dict by default."""
@@ -173,7 +173,7 @@ class TitlesTestCase(TestCase):
 
     def test_get_extra_context_is_used_during_render(self):
         """Test that get_extra_context is being used to extend the context."""
-        context = Context({})
+        context = Context({"view_action": "list"})
 
         class TitlesSubClass(Titles):
             def get_extra_context(self, context: Context) -> dict:

nautobot/core/tests/test_ui.py

@@ -7,7 +7,7 @@ from django.test import RequestFactory
 
 from nautobot.core.templatetags.helpers import HTML_NONE
 from nautobot.core.testing import TestCase
-from nautobot.core.ui.object_detail import BaseTextPanel, DataTablePanel, ObjectsTablePanel, Panel
+from nautobot.core.ui.object_detail import BaseTextPanel, DataTablePanel, ObjectFieldsPanel, ObjectsTablePanel, Panel
 from nautobot.dcim.models import DeviceRedundancyGroup
 from nautobot.dcim.tables.devices import DeviceTable
 
@@ -68,6 +68,19 @@ class DataTablePanelTest(TestCase):
         )
 
 
+class ObjectFieldsPanelTest(TestCase):
+    def test_get_data_ignore_nonexistent_fields(self):
+        panel = ObjectFieldsPanel(weight=100, fields=["name", "foo", "bar"], ignore_nonexistent_fields=True)
+        redundancy_group = DeviceRedundancyGroup.objects.first()
+        context = Context({"object": redundancy_group})
+        data = panel.get_data(context)
+        self.assertEqual(data, {"name": redundancy_group.name})  # no keys for nonexistent fields
+
+        panel = ObjectFieldsPanel(weight=100, fields=["name", "foo", "bar"], ignore_nonexistent_fields=False)
+        with self.assertRaises(AttributeError):
+            data = panel.get_data(context)
+
+
 class BaseTextPanelTest(TestCase):
     def test_init_set_object_params(self):
         # Test default settings