nautobot 2.3.16__py3-none-any.whl → 2.4.0b1__py3-none-any.whl

nautobot/core/templates/inc/footer.html

@@ -41,6 +41,7 @@
                             <a href="{% static 'docs/index.html' %}">Docs</a>
                         {% endif %}
                         &middot;
+                        <img src="{% static 'img/jinja_logo.svg' %}" style="height:20px"> <a href="{% url 'render_jinja_template' %}">Jinja Renderer</a> &middot;
                         <i class="mdi mdi-cloud-braces text-primary"></i> <a href="{% url 'api_docs' %}">API</a> &middot;
                         <i class="mdi mdi-graphql text-primary"></i> <a href="{% url 'graphql' %}">GraphQL</a> &middot;
                         <i class="mdi mdi-xml text-primary"></i> <a href="{{ settings.BRANDING_URLS.code }}">Code</a> &middot;

nautobot/core/templates/inc/media.html

@@ -47,6 +47,3 @@
     <meta name="theme-color" content="#ffffff">
     <meta charset="UTF-8">
     <meta name="viewport" content="initial-scale=1, maximum-scale=1, user-scalable=no, width=device-width">
-    {% if settings.PUBLISH_ROBOTS_TXT %}
-    <meta name="robots" content="noindex, nofollow">
-    {% endif %}

nautobot/core/templates/inc/nav_menu.html

@@ -56,7 +56,7 @@
                                                                         {% endcomment %}
                                                                         {% url button_details.link as button_url %}
                                                                         {% if button_url %}
-                                                                            <a href="{{ button_url }}"
+                                                                            <a href="{{ button_url }}{{ button_details.querystring }}"
                                                                                data-button-weight="{{ button_details.weight }}"
                                                                                class="btn btn-xs btn-{{ button_details.button_class }}"
                                                                                title="{{ button_title }}">

nautobot/core/templates/inc/relationships_panel.html

@@ -7,7 +7,7 @@
                 <strong>Relationships</strong>
             </div>
             <table class="table table-hover panel-body attr-table">
-                {% include 'inc/relationships_table_rows.html' with relationships_data=object.get_relationships_data %}
+                {% include 'inc/relationships_table_rows.html' with relationships_data=relationships %}
             </table>
         </div>
     {% endif %}

nautobot/core/templates/nautobot_config.py.j2

@@ -364,6 +364,9 @@ SECRET_KEY = os.getenv("NAUTOBOT_SECRET_KEY", "{{ secret_key }}")
 # if "NAUTOBOT_DEVICE_NAME_AS_NATURAL_KEY" in os.environ and os.environ["NAUTOBOT_DEVICE_NAME_AS_NATURAL_KEY"] != "":
 #     DEVICE_NAME_AS_NATURAL_KEY = is_truthy(os.environ["NAUTOBOT_DEVICE_NAME_AS_NATURAL_KEY"])
 
+# Event Brokers
+# EVENT_BROKERS = {}
+
 # Exempt certain models from the enforcement of view permissions. Models listed here will be viewable by all users and
 # by anonymous users. List models in the form `<app>.<model>`. Add '*' to this list to exempt all models.
 # Defaults to [].
@@ -490,9 +493,6 @@ INSTALLATION_METRICS_ENABLED = is_truthy(os.getenv("NAUTOBOT_INSTALLATION_METRIC
 # if "NAUTOBOT_PREFER_IPV4" in os.environ and os.environ["NAUTOBOT_PREFER_IPV4"] != "":
 #     PREFER_IPV4 = is_truthy(os.environ["NAUTOBOT_PREFER_IPV4"])
 
-# Publish a simple "no-index" robots.txt for Nautobot?
-# PUBLISH_ROBOTS_TXT = is_truthy(os.getenv("NAUTOBOT_PUBLISH_ROBOTS_TXT", "True"))
-
 # Default height and width in pixels of a single rack unit in rendered rack elevations. Defaults are 22 and 230
 #
 # if (

nautobot/core/templates/panel_table.html

@@ -1,4 +1,5 @@
 {% load render_table from django_tables2 %}
+{% load helpers %}
 
 <div class="panel panel-{{ panel_class|default:'default' }}">
     {% if heading %}
@@ -13,4 +14,15 @@
     {% else %}
         <div class="panel-body text-muted">None</div>
     {% endif %}
+    {% if add_obj_url %}
+        <div class="panel-footer noprint">
+            <div class="pull-right">
+                <a href="{{ add_obj_url }}" class="btn btn-primary btn-xs">
+                    <span class="mdi mdi-plus-thick" aria-hidden="true"></span> Add {{ table.data.data.model|meta:"verbose_name" }}
+                </a>
+            </div>
+        
+            <div class="clearfix"></div>
+        </div>
+    {% endif %}
 </div>

nautobot/core/templates/search.html

@@ -65,10 +65,3 @@
         </div>
     {% endif %}
 {% endblock %}
-
-{% block javascript %}
-    {{ block.super }}
-    <script>
-        var clipboard = new ClipboardJS('.btn');
-    </script>
-{% endblock %}

nautobot/core/templates/utilities/render_jinja2.html

@@ -0,0 +1,117 @@
+{% extends "base.html" %}
+{% load form_helpers %}
+{% load helpers %}
+{% load static %}
+
+{% block extra_styles %}
+<style type="text/css">
+    .button-container {
+        margin-bottom: 24px;
+    }
+    #render_jinja_template_form textarea {
+        resize: vertical;
+        white-space: nowrap;
+    }
+
+</style>
+{% endblock extra_styles %}
+
+{% block header %}
+<h1>{% block title %}Jinja Template Renderer{% endblock %}</h1>
+<hr>
+{% endblock %}
+
+
+
+{% block content %}
+<form class="form form-horizontal" onsubmit="handleFormSubmit(event)" id="render_jinja_template_form">
+    <div class="row">
+        <div class="col-lg-6 col-md-6">
+            <div class="panel panel-default">
+                <div class="panel-heading"><strong>Template</strong></div>
+                <div class="panel-body">
+                    <div class="form-group">
+                        <label class="col-md-3 control-label required" for="id_template_code">Jinja Template</label>
+                        <div class="col-md-9">
+                            <textarea cols="40" rows="10" class="form-control" id="id_template_code" required=""></textarea>
+                        </div>
+                    </div>
+                    <div class="form-group">
+                        <label class="col-md-3 control-label" for="id_context">Data</label>
+                        <div class="col-md-9">
+                            <textarea cols="40" rows="10" class="form-control" placeholder="{}" id="id_context">{}</textarea>
+                            <span class="help-block">Enter data in <a href="https://json.org/">JSON</a> format.</span>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            <div class="button-container text-right">
+                <button type="submit" class="btn btn-primary">Render</button>
+            </div>
+        </div>
+        <div class="col-lg-6 col-md-6">
+            <div class="panel panel-default">
+                <div class="panel-heading">
+                    <strong>Rendered Template</strong>
+                    <button type="button" class="btn btn-inline btn-default copy-rendered-template" data-clipboard-target="#rendered_template">
+                        <span class="mdi mdi-content-copy"></span>
+                    </button>
+                </div>
+                <div class="panel-body">
+                    <textarea readonly="readonly" cols="40" rows="23" class="form-control" placeholder="Rendered Template" id="rendered_template"></textarea>
+                </div>
+            </div>
+        </div>
+    </div>
+</form>
+{% endblock content %}
+
+{% block javascript %}
+    {{ block.super }}
+    <script>
+        new ClipboardJS('.copy-rendered-template');
+        const sanitize = function(string) {
+            return string.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+        };
+        async function handleFormSubmit(event) {
+            event.preventDefault(); // Prevent default form submission
+
+            // Check that the context is valid JSON
+            const context = document.getElementById("id_context");
+            var parsed_context;
+            try {
+                parsed_context = JSON.parse(context.value);
+            } catch (error) {
+                context.setCustomValidity("Invalid JSON");
+                context.reportValidity();
+                context.setCustomValidity("");
+                return error;
+            }
+
+            try {
+                const rendered_template = document.getElementById("rendered_template");
+                rendered_template.innerHTML = "Loading...";
+                const template_code = document.getElementById("id_template_code").value;
+                const url = "{% url 'core-api:render_jinja_template' %}";
+                const data = {
+                    template_code: template_code,
+                    context: parsed_context
+                }
+                const response = await fetch(url, {
+                    method: "POST",
+                    body: JSON.stringify(data),
+                    headers: {"Content-Type": "application/json", "X-CSRFTOKEN": "{{ csrf_token }}"}
+                });
+                const responseData = await response.json();
+                if (!response.ok) {
+                    const msg = responseData.detail ? responseData.detail : response.statusText;
+                    rendered_template.innerHTML = sanitize(`An error occurred:\n\n${msg}`);
+                } else {
+                    rendered_template.innerHTML = sanitize(responseData.rendered_template);
+                }
+            } catch (error) {
+                rendered_template.innerHTML = sanitize(`An error occurred:\n\n${error.message}`);
+            }
+        }
+    </script>
+{% endblock javascript %}

nautobot/core/templatetags/helpers.py

@@ -21,6 +21,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.requests import add_nautobot_version_query_param_to_url
 
@@ -118,6 +119,26 @@ def placeholder(value):
     return HTML_NONE
 
 
+@library.filter()
+@register.filter()
+def pre_tag(value):
+    """Render a value within `<pre></pre>` tags to enable formatting.
+
+    Args:
+        value (any): Input value, can be any variable.
+
+    Returns:
+        (str): Value wrapped in `<pre></pre>` tags.
+
+    Example:
+        >>> pre_tag("")
+        '<pre></pre>'
+        >>> pre_tag("hello")
+        '<pre>hello</pre>'
+    """
+    return format_html("<pre>{}</pre>", value)
+
+
 @library.filter()
 @register.filter()
 def add_html_id(element_str, id_str):
@@ -202,6 +223,29 @@ def render_json(value, syntax_highlight=True, pretty_print=False):
 
     Unless `syntax_highlight=False` is specified, the returned string will be wrapped in a
     `<code class="language-json>` HTML tag to flag it for syntax highlighting by highlight.js.
+
+    Args:
+        value (any): Input value, can be any variable.
+        syntax_highlight (bool): Whether to highlight the JSON syntax or not.
+        pretty_print (bool): Wraps rendered and highlighted JSON in <pre> tag for better code display.
+
+    Returns:
+        (str): HTML
+            '<code class="language-json">{"json_key": "json_value"}</code>' if only syntax_highlight is True
+            - or -
+            '<pre><code class="language-json">{"json_key": "json_value"}</code></pre>' if both syntax_highlight and pretty_print are True
+            - or -
+            '{"json_key": "json_value"}' if only pretty_print is True (both syntax_highlight and pretty_print must be True for pretty print)
+
+    Examples:
+        >>> render_json({"key": "value"})
+        '<code class="language-json">{"key": "value"}</code>'
+        >>> render_json({"key": "value"}, syntax_highlight=False)
+        '{"key": "value"}'
+        >>> render_json({"key": "value"}, pretty_print=True)
+        '<pre><code class="language-json">{"key": "value"}</code></pre>'
+        >>> render_json({"key": "value"}, syntax_highlight=False, pretty_print=True)
+        '{"key": "value"}'
     """
     rendered_json = json.dumps(value, indent=4, sort_keys=True, ensure_ascii=False)
     if syntax_highlight:
@@ -616,6 +660,57 @@ def render_uptime(seconds):
     )
 
 
+@library.filter()
+@register.filter()
+def dbm(value):
+    """Display value as dBm."""
+    return f"{value} dBm" if value else placeholder(value)
+
+
+@library.filter()
+@register.filter()
+def hyperlinked_field(value, hyperlink=None):
+    """Render a value as a hyperlink."""
+    if not value:
+        return placeholder(value)
+    hyperlink = hyperlink or value
+    return format_html('<a href="{}">{}</a>', hyperlink, value)
+
+
+@library.filter()
+@register.filter()
+def render_content_types(value):
+    """Render sorted by model and app_label ContentTypes value"""
+    if not value.exists():
+        return HTML_NONE
+    output = format_html("<ul>")
+    sorted_value = value.order_by("app_label", "model")
+    for content_type in sorted_value:
+        output += format_html("<li>{content_type}</li>", content_type=content_type)
+    output += format_html("</ul>")
+
+    return output
+
+
+@library.filter()
+@register.filter()
+def render_ancestor_hierarchy(value):
+    """Renders a nested HTML list representing the hierarchy of ancestors for a given object."""
+    result = format_html('<ul class="tree-hierarchy">')
+    append_to_result = format_html("</ul>")
+    for ancestor in value.ancestors():
+        nestable_tag = format_html('<span title="nestable">↺</span>' if getattr(ancestor, "nestable", False) else "")
+        result += format_html(
+            "<li>{value} {nestable_tag}<ul>", value=hyperlinked_object(ancestor, "name"), nestable_tag=nestable_tag
+        )
+        append_to_result += format_html("</ul></li>")
+    nestable_tag = format_html('<span title="nestable">↺</span>' if getattr(value, "nestable", False) else "")
+    result += format_html("<li><strong>{value} {nestable_tag}</strong></li>", value=value, nestable_tag=nestable_tag)
+    result += append_to_result
+
+    return result
+
+
 #
 # Tags
 #
@@ -645,15 +740,15 @@ def querystring(request, **kwargs):
 
 
 @register.simple_tag()
-def table_config_button(table, table_name=None, extra_classes=""):
+def table_config_button(table, table_name=None, extra_classes="", disabled=False):
     if table_name is None:
         table_name = table.__class__.__name__
     html_template = (
         '<button type="button" class="btn btn-default {}'
-        '" data-toggle="modal" data-target="#{}_config" title="Configure table">'
+        '" data-toggle="modal" data-target="#{}_config" {} title="Configure table">'
         '<i class="mdi mdi-cog"></i> Configure</button>'
     )
-    return format_html(html_template, extra_classes, table_name)
+    return format_html(html_template, extra_classes, table_name, 'disabled="disabled"' if disabled else "")
 
 
 @register.simple_tag()
@@ -795,13 +890,7 @@ def saved_view_modal(
         "clear_view",
     ]
 
-    view_class = lookup.get_view_for_model(model, "List")
-    table_name = None
-    if hasattr(view_class, "table"):
-        table_name = view_class.table.__name__
-    if hasattr(view_class, "table_class"):
-        table_name = view_class.table_class.__name__
-
+    table_name = lookup.get_table_for_model(model).__name__
     for param in non_filter_params:
         if param == "saved_view":
             current_saved_view_pk = filters_applied.pop(param, None)
@@ -852,11 +941,11 @@ def saved_view_modal(
     elif current_saved_view is not None and not per_page:
         # no changes made, display current saved view pagination count
         param_dict["per_page"] = current_saved_view.config.get(
-            "pagination_count", config.get_settings_or_config("PAGINATE_COUNT")
+            "pagination_count", config.get_settings_or_config("PAGINATE_COUNT", fallback=PAGINATE_COUNT_DEFAULT)
         )
     else:
         # display default pagination count
-        param_dict["per_page"] = config.get_settings_or_config("PAGINATE_COUNT")
+        param_dict["per_page"] = config.get_settings_or_config("PAGINATE_COUNT", fallback=PAGINATE_COUNT_DEFAULT)
 
     if sort_order:
         # user made changes to saved view sort order

nautobot/core/templatetags/ui_framework.py

@@ -0,0 +1,40 @@
+from django import template
+from django.utils.html import format_html_join
+
+from nautobot.core.utils.lookup import get_view_for_model
+from nautobot.core.views.utils import get_obj_from_context
+
+register = template.Library()
+
+
+@register.simple_tag(takes_context=True)
+def render_tabs_labels(context, tabs):
+    """Render the tab labels for each Tab in the given `tabs` with the given `context`."""
+    if tabs is not None:
+        return format_html_join("\n", "{}", ([tab.render_label_wrapper(context)] for tab in tabs))
+    return ""
+
+
+@register.simple_tag(takes_context=True)
+def render_components(context, components):
+    """Render each component in the given `components` with the given `context`."""
+    if components is not None:
+        return format_html_join("\n", "{}", ([component.render(context)] for component in components))
+    return ""
+
+
+@register.simple_tag(takes_context=True)
+def render_detail_view_extra_buttons(context):
+    """
+    Render the "extra_buttons" if any from the base detail view associated with the context object.
+
+    This makes it possible for "extra" tabs (such as Changelog and Notes, and any added by App TemplateExtensions)
+    to automatically still render any `extra_buttons` defined by the base detail view, without the tab-specific views
+    needing to explicitly inherit from the base view.
+    """
+    obj = get_obj_from_context(context)
+    base_detail_view = get_view_for_model(obj)
+    object_detail_content = getattr(base_detail_view, "object_detail_content", None)
+    if object_detail_content is not None and object_detail_content.extra_buttons:
+        return render_components(context, object_detail_content.extra_buttons)
+    return ""

nautobot/core/testing/api.py

@@ -16,7 +16,6 @@ from rest_framework.test import APITransactionTestCase as _APITransactionTestCas
 from nautobot.core.api.utils import get_serializer_for_model
 from nautobot.core.models import fields as core_fields
 from nautobot.core.models.tree_queries import TreeModel
-from nautobot.core.templatetags.helpers import bettertitle
 from nautobot.core.testing import mixins, utils, views
 from nautobot.core.utils import lookup
 from nautobot.core.utils.data import is_uuid
@@ -169,6 +168,10 @@ class APIViewTestCases:
             if issubclass(self.model, extras_models.ChangeLoggedModel):
                 self.assertIn("created", response.data)
                 self.assertIn("last_updated", response.data)
+            if hasattr(self.model, "notes") and isinstance(instance1.notes, QuerySet):
+                self.assertIn("notes_url", response.data)
+                self.assertIn(f"{url}notes/", str(response.data["notes_url"]))
+                self.assertIn(instance1.get_notes_url(api=True), str(response.data["notes_url"]))
             # Fields that should be absent by default (opt-in fields):
             self.assertNotIn("computed_fields", response.data)
             self.assertNotIn("relationships", response.data)
@@ -218,58 +221,6 @@ class APIViewTestCases:
             response = self.client.options(url, **self.header)
             self.assertHttpStatus(response, status.HTTP_200_OK)
 
-            with self.subTest("Assert Detail View Config is generated well"):
-                # Namings Help
-                # 1. detail_view_config: This is the detail view config set in the serializer.Meta.detail_view_config
-                # 2. detail_view_schema: This is the retrieve schema generated from an OPTIONS request.
-                # 3. advanced_view_schema: This is the advanced tab schema generated from an OPTIONS request.
-                serializer = get_serializer_for_model(self._get_queryset().model)
-                advanced_view_schema = response.data["view_options"]["retrieve"]["tabs"]["Advanced"]
-
-                # Get default advanced tab fields
-                self.assertEqual(len(advanced_view_schema), 1)
-                self.assertIn("Object Details", advanced_view_schema[0])
-                advanced_tab_fields = advanced_view_schema[0].get("Object Details")["fields"]
-
-                if detail_view_config := getattr(serializer.Meta, "detail_view_config", None):
-                    detail_view_schema = response.data["view_options"]["retrieve"]["tabs"][
-                        bettertitle(self._get_queryset().model._meta.verbose_name)
-                    ]
-                    self.assertHttpStatus(response, status.HTTP_200_OK)
-
-                    # According to convention, fields in the advanced tab fields should not exist in
-                    # the `detail_view_schema`. Assert this is True.
-                    with self.subTest("Assert advanced tab fields should not exist in the detail_view_schema."):
-                        if detail_view_config.get("include_others"):
-                            # Handle "Other Fields" section specially as "Other Field" is dynamically added
-                            # by Nautobot and is not part of the serializer-defined detail_view_config
-                            other_fields = detail_view_schema[0]["Other Fields"]["fields"]
-                            for field in advanced_tab_fields:
-                                self.assertNotIn(field, other_fields)
-
-                        for col_idx, col in enumerate(detail_view_schema):
-                            for group_title, group in col.items():
-                                if group_title == "Other Fields":
-                                    continue
-                                group_fields = group["fields"]
-                                # Config on the serializer
-                                if (
-                                    col_idx < len(detail_view_config["layout"])
-                                    and group_title in detail_view_config["layout"][col_idx]
-                                ):
-                                    fields = detail_view_config["layout"][col_idx][group_title]["fields"]
-                                else:
-                                    fields = []
-
-                                # Fields that are in the detail_view_schema must not be in the advanced tab as well
-                                for field in group_fields:
-                                    self.assertNotIn(field, advanced_tab_fields)
-
-                                # Fields that are explicit in the detail_view_config must remain as such in the schema
-                                for field in fields:
-                                    if field not in advanced_tab_fields:
-                                        self.assertIn(field, group_fields)
-
     class ListObjectsViewTestCase(APITestCase):
         choices_fields = None
         filterset = None
@@ -637,10 +588,7 @@ class APIViewTestCases:
             POST a single object with permission.
             """
             # Add object-level permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["add"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.add_{self.model._meta.model_name}")
 
             initial_count = self._get_queryset().count()
             for i, create_data in enumerate(self.create_data):
@@ -683,10 +631,10 @@ class APIViewTestCases:
                 self.fail("Couldn't find a single deletable object!")
 
             # Add object-level permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["add", "view"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(
+                f"{self.model._meta.app_label}.add_{self.model._meta.model_name}",
+                f"{self.model._meta.app_label}.view_{self.model._meta.model_name}",
+            )
 
             response = self.client.get(self._get_detail_url(instance) + "?format=csv", **self.header)
             self.assertHttpStatus(response, status.HTTP_200_OK)
@@ -707,11 +655,7 @@ class APIViewTestCases:
             self.assertHttpStatus(response, status.HTTP_201_CREATED, csv_data)
             # Note that create via CSV is always treated as a bulk-create, and so the response is always a list of dicts
             new_instance = self._get_queryset().get(pk=response.data[0]["id"])
-            if isinstance(orig_pk, int):
-                self.assertNotEqual(new_instance.pk, orig_pk)
-            else:
-                # for our non-integer PKs, we're expecting the creation to respect the requested PK
-                self.assertEqual(new_instance.pk, orig_pk)
+            self.assertNotEqual(new_instance.pk, orig_pk)
 
             new_serializer = serializer_class(new_instance, context={"request": None})
             new_data = new_serializer.data
@@ -739,10 +683,7 @@ class APIViewTestCases:
             POST a set of objects in a single request.
             """
             # Add object-level permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["add"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.add_{self.model._meta.model_name}")
 
             initial_count = self._get_queryset().count()
             response = self.client.post(self._get_list_url(), self.create_data, format="json", **self.header)
@@ -873,10 +814,10 @@ class APIViewTestCases:
             """GET and then PUT an object and verify that it's accepted and unchanged."""
             self.maxDiff = None
             # Add object-level permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["view", "change"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(
+                f"{self.model._meta.app_label}.view_{self.model._meta.model_name}",
+                f"{self.model._meta.app_label}.change_{self.model._meta.model_name}",
+            )
 
             instance = self._get_queryset().first()
             url = self._get_detail_url(instance)
@@ -907,10 +848,7 @@ class APIViewTestCases:
                 self.skipTest("Bulk update data not set")
 
             # Add object-level permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["change"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.change_{self.model._meta.model_name}")
 
             id_list = list(self._get_queryset().values_list("id", flat=True)[:3])
             self.assertEqual(len(id_list), 3, "Insufficient number of objects to test bulk update")
@@ -954,24 +892,11 @@ class APIViewTestCases:
             self.assertIn("actions", data)
 
             # Grab any field that has choices defined (fields with enums)
-            if any(
-                [
-                    "POST" in data["actions"],
-                    "PUT" in data["actions"],
-                ]
-            ):
-                schema = data["schema"]
-                props = schema["properties"]
-                fields = props.keys()
-                field_choices = set()
-                for field_name in fields:
-                    obj = props[field_name]
-                    if "enum" in obj and "enumNames" in obj:
-                        enum = obj["enum"]
-                        # Zipping to assert that the enum and the mapping have the same number of items.
-                        model_field_choices = dict(zip(obj["enumNames"], enum))
-                        self.assertEqual(len(enum), len(model_field_choices))
-                        field_choices.add(field_name)
+            field_choices = {}
+            if "POST" in data["actions"]:
+                field_choices = {k for k, v in data["actions"]["POST"].items() if "choices" in v}
+            elif "PUT" in data["actions"]:
+                field_choices = {k for k, v in data["actions"]["PUT"].items() if "choices" in v}
             else:
                 self.fail(f"Neither PUT nor POST are available actions in: {data['actions']}")
 
@@ -1026,10 +951,7 @@ class APIViewTestCases:
             url = self._get_detail_url(instance)
 
             # Add object-level permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["delete"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.delete_{self.model._meta.model_name}")
 
             response = self.client.delete(url, **self.header)
             self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
@@ -1046,10 +968,7 @@ class APIViewTestCases:
             """
             id_list = self.get_deletable_object_pks()
             # Add object-level permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["delete"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.delete_{self.model._meta.model_name}")
 
             data = [{"id": id} for id in id_list]
 
@@ -1061,30 +980,6 @@ class APIViewTestCases:
     class NotesURLViewTestCase(APITestCase):
         """Validate Notes URL on objects that have the Note model Mixin."""
 
-        @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
-        def test_notes_url_on_object(self):
-            if not hasattr(self.model, "notes"):
-                self.skipTest("Model doesn't appear to support Notes")
-            instance = self._get_queryset().first()
-            if not isinstance(instance.notes, QuerySet):
-                self.skipTest("Model has a notes field but it doesn't appear to be Notes")
-
-            # Add object-level permission
-            obj_perm = users_models.ObjectPermission(
-                name="Test permission",
-                constraints={"pk": instance.pk},
-                actions=["view"],
-            )
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
-            url = self._get_detail_url(instance)
-            response = self.client.get(url, **self.header)
-            self.assertHttpStatus(response, status.HTTP_200_OK)
-            self.assertIn("notes_url", response.data)
-            self.assertIn(f"{url}notes/", str(response.data["notes_url"]))
-            self.assertIn(instance.get_notes_url(api=True), str(response.data["notes_url"]))
-
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_notes_url_functionality(self):
             if not hasattr(self.model, "notes"):