nautobot 2.2.9__py3-none-any.whl → 2.3.0b1__py3-none-any.whl

nautobot/core/templatetags/form_helpers.py

@@ -45,7 +45,7 @@ def render_form(form, excluded_fields=None):
     https://github.com/nautobot/nautobot/issues/4503
     """
     if excluded_fields is None:
-        excluded_fields = ["tags", "object_note"]
+        excluded_fields = ["tags", "dynamic_groups", "object_note"]
 
     return {
         "form": form,

nautobot/core/templatetags/helpers.py

@@ -2,10 +2,14 @@ import datetime
 import json
 import logging
 import re
+from urllib.parse import parse_qs
 
 from django import template
 from django.conf import settings
+from django.contrib import messages
+from django.contrib.auth.models import AnonymousUser
 from django.contrib.staticfiles.finders import find
+from django.core.exceptions import ObjectDoesNotExist
 from django.templatetags.static import static, StaticNode
 from django.urls import NoReverseMatch, reverse
 from django.utils.html import format_html, format_html_join
@@ -192,7 +196,7 @@ def render_markdown(value):
 
 @library.filter()
 @register.filter()
-def render_json(value, syntax_highlight=True):
+def render_json(value, syntax_highlight=True, pretty_print=False):
     """
     Render a dictionary as formatted JSON.
 
@@ -201,7 +205,11 @@ def render_json(value, syntax_highlight=True):
     """
     rendered_json = json.dumps(value, indent=4, sort_keys=True, ensure_ascii=False)
     if syntax_highlight:
-        return format_html('<code class="language-json">{}</code>', rendered_json)
+        html_string = '<code class="language-json">{}</code>'
+        if pretty_print:
+            html_string = "<pre>" + html_string + "</pre>"
+        return format_html(html_string, rendered_json)
+
     return rendered_json
 
 
@@ -581,6 +589,33 @@ def slugify(value):
     return django_slugify(value)
 
 
+@library.filter()
+@register.filter()
+def render_uptime(seconds):
+    """Format a value in seconds to a human readable value.
+
+    Example:
+        >>> render_uptime(1024768)
+        "11 days 20 hours 39 minutes"
+    """
+    try:
+        seconds = int(seconds)
+    except ValueError:
+        return placeholder(seconds)
+    delta = datetime.timedelta(seconds=seconds)
+    uptime_hours = delta.seconds // 3600
+    uptime_minutes = delta.seconds // 60 % 60
+    return format_html(
+        "{} {} {} {} {} {}",
+        delta.days,
+        "days" if delta.days != 1 else "day",
+        uptime_hours,
+        "hours" if uptime_hours != 1 else "hour",
+        uptime_minutes,
+        "minutes" if uptime_minutes != 1 else "minute",
+    )
+
+
 #
 # Tags
 #
@@ -609,6 +644,23 @@ def querystring(request, **kwargs):
         return ""
 
 
+@register.simple_tag()
+def table_config_button(table, table_name=None, extra_classes=""):
+    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">'
+        '<i class="mdi mdi-cog"></i> Configure</button>'
+    )
+    return format_html(html_template, extra_classes, table_name)
+
+
+@register.simple_tag()
+def table_config_button_small(table, table_name=None):
+    return table_config_button(table, table_name, "btn-xs")
+
+
 @register.inclusion_tag("utilities/templatetags/utilization_graph.html")
 def utilization_graph(utilization_data, warning_threshold=75, danger_threshold=90):
     """Wrapper for a horizontal bar graph indicating a percentage of utilization from a tuple of data.
@@ -714,6 +766,121 @@ def filter_form_modal(
     }
 
 
+@register.inclusion_tag("utilities/templatetags/saved_view_modal.html")
+def saved_view_modal(
+    params,
+    view,
+    model,
+    request,
+):
+    from nautobot.extras.forms import SavedViewModalForm
+    from nautobot.extras.models import SavedView
+
+    param_dict = {}
+    filters_applied = parse_qs(params)
+
+    sort_order = []
+    per_page = None
+    table_changes_pending = False
+    all_filters_removed = False
+    current_saved_view = None
+    current_saved_view_pk = None
+    non_filter_params = [
+        "all_filters_removed",
+        "page",
+        "per_page",
+        "sort",
+        "saved_view",
+        "table_changes_pending",
+        "clear_view",
+    ]
+
+    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)
+            if current_saved_view_pk:
+                current_saved_view_pk = current_saved_view_pk[0]
+                try:
+                    # We are not using .restrict(request.user, "view") here
+                    # User should be able to see any saved view that he has the list view access to.
+                    current_saved_view = SavedView.objects.get(pk=current_saved_view_pk)
+                except ObjectDoesNotExist:
+                    messages.error(request, f"Saved view {current_saved_view_pk} not found")
+
+        elif param == "table_changes_pending":
+            table_changes_pending = filters_applied.pop(param, False)
+        elif param == "all_filters_removed":
+            all_filters_removed = filters_applied.pop(param, False)
+        elif param == "per_page":
+            per_page = filters_applied.pop(param, None)
+        elif param == "sort":
+            sort_order = filters_applied.pop(param, [])
+        elif param == "clear_view":
+            filters_applied.pop(param, False)
+
+    if filters_applied:
+        param_dict["filter_params"] = filters_applied
+    else:
+        if (current_saved_view is not None and all_filters_removed) or (current_saved_view is None):
+            # user removed all the filters in a saved view
+            param_dict["filter_params"] = {}
+        elif current_saved_view is not None:
+            # user did not make any changes to the saved view filter params
+            param_dict["filter_params"] = current_saved_view.config.get("filter_params", {})
+
+    if current_saved_view is not None and not table_changes_pending:
+        # user did not make any changes to the saved view table config
+        view_table_config = current_saved_view.config.get("table_config", {}).get(f"{table_name}", None)
+        if view_table_config is not None:
+            param_dict["table_config"] = view_table_config.get("columns", [])
+    else:
+        # display default user display
+        if request.user is not None and not isinstance(request.user, AnonymousUser):
+            param_dict["table_config"] = request.user.get_config(f"tables.{table_name}.columns")
+    # If both are not available, do not display table_config
+
+    if per_page:
+        # user made changes to saved view pagination count
+        param_dict["per_page"] = per_page
+    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")
+        )
+    else:
+        # display default pagination count
+        param_dict["per_page"] = config.get_settings_or_config("PAGINATE_COUNT")
+
+    if sort_order:
+        # user made changes to saved view sort order
+        param_dict["sort_order"] = sort_order
+    elif current_saved_view is not None and not sort_order:
+        # no changes made, display current saved view sort order
+        param_dict["sort_order"] = current_saved_view.config.get("sort_order", [])
+    else:
+        # no sorting applied
+        param_dict["sort_order"] = []
+
+    param_dict = json.dumps(param_dict, indent=4, sort_keys=True, ensure_ascii=False)
+    return {
+        "form": SavedViewModalForm(),
+        "params": params,
+        "param_dict": param_dict,
+        "view": view,
+    }
+
+
+@register.inclusion_tag("utilities/templatetags/dynamic_group_assignment_modal.html")
+def dynamic_group_assignment_modal(request, content_type):
+    from nautobot.extras.forms import DynamicGroupBulkAssignForm
+
+    return {
+        "request": request,
+        "form": DynamicGroupBulkAssignForm(model=content_type.model_class()),
+    }
+
+
 @register.inclusion_tag("utilities/templatetags/modal_form_as_dialog.html")
 def modal_form_as_dialog(form, editing=False, form_name=None, obj=None, obj_type=None):
     """Generate a form in a modal view.
@@ -806,7 +973,7 @@ def hyperlinked_object_with_color(obj):
     if obj:
         content = f'<span class="label" style="color: {fgcolor(obj.color)}; background-color: #{obj.color}">{hyperlinked_object(obj)}</span>'
         return format_html(content)
-    return "—"
+    return HTML_NONE
 
 
 @register.filter()
@@ -870,12 +1037,15 @@ def _build_hyperlink(value, field="", target="", rel=""):
     attributes = {}
     display = getattr(value, field) if hasattr(value, field) else str(value)
     if hasattr(value, "get_absolute_url"):
-        attributes["href"] = value.get_absolute_url()
-        if hasattr(value, "description") and value.description:
-            attributes["title"] = value.description
-        if target:
-            attributes["target"] = target
-        if rel:
-            attributes["rel"] = rel
-        return format_html("<a {}>{}</a>", format_html_join(" ", '{}="{}"', attributes.items()), display)
+        try:
+            attributes["href"] = value.get_absolute_url()
+            if hasattr(value, "description") and value.description:
+                attributes["title"] = value.description
+            if target:
+                attributes["target"] = target
+            if rel:
+                attributes["rel"] = rel
+            return format_html("<a {}>{}</a>", format_html_join(" ", '{}="{}"', attributes.items()), display)
+        except AttributeError:
+            pass
     return format_html("{}", display)

nautobot/core/testing/api.py

@@ -740,7 +740,11 @@ class APIViewTestCases:
 
             initial_count = self._get_queryset().count()
             response = self.client.post(self._get_list_url(), self.create_data, format="json", **self.header)
-            self.assertHttpStatus(response, status.HTTP_201_CREATED)
+            self.assertHttpStatus(
+                response,
+                status.HTTP_201_CREATED,
+                msg=f"create_data: {self.create_data}\nexisting records: {list(self._get_queryset())}",
+            )
             self.assertEqual(len(response.data), len(self.create_data))
             self.assertEqual(self._get_queryset().count(), initial_count + len(self.create_data))
             for i, obj in enumerate(response.data):
@@ -841,7 +845,6 @@ class APIViewTestCases:
             # This may change (hah) at some point -- see https://github.com/nautobot/nautobot/issues/3321
             if hasattr(self.model, "to_objectchange"):
                 objectchanges = lookup.get_changes_for_model(instance)
-                self.assertEqual(len(objectchanges), 1)
                 self.assertEqual(objectchanges[0].action, extras_choices.ObjectChangeActionChoices.ACTION_UPDATE)
                 objectchanges.delete()
 
@@ -858,7 +861,6 @@ class APIViewTestCases:
             # Verify ObjectChange creation
             if hasattr(self.model, "to_objectchange"):
                 objectchanges = lookup.get_changes_for_model(instance)
-                self.assertEqual(len(objectchanges), 1)
                 self.assertEqual(objectchanges[0].action, extras_choices.ObjectChangeActionChoices.ACTION_UPDATE)
 
         def test_get_put_round_trip(self):
@@ -1030,7 +1032,6 @@ class APIViewTestCases:
             # Verify ObjectChange creation
             if hasattr(self.model, "to_objectchange"):
                 objectchanges = lookup.get_changes_for_model(instance)
-                self.assertEqual(len(objectchanges), 1)
                 self.assertEqual(objectchanges[0].action, extras_choices.ObjectChangeActionChoices.ACTION_DELETE)
 
         def test_bulk_delete_objects(self):

nautobot/core/testing/filters.py

@@ -3,10 +3,12 @@ import string
 
 from django.contrib.contenttypes.models import ContentType
 from django.db.models import Count, Q
+from django.db.models.fields import CharField, TextField
 from django.db.models.fields.related import ManyToManyField
 from django.db.models.fields.reverse_related import ManyToManyRel, ManyToOneRel
 from django.test import tag
 
+from nautobot.core.constants import CHARFIELD_MAX_LENGTH
 from nautobot.core.filters import (
     ContentTypeChoiceFilter,
     ContentTypeFilter,
@@ -16,6 +18,7 @@ from nautobot.core.filters import (
 )
 from nautobot.core.models.generics import PrimaryModel
 from nautobot.core.testing import views
+from nautobot.extras.models import Contact, ContactAssociation, Role, Status, Tag, Team
 from nautobot.tenancy import models
 
 
@@ -119,6 +122,31 @@ class FilterTestCases:
                     )
                 This expects a field named `devices` on the model and a filter named `devices` on the filterset.
             """
+            if getattr(self.queryset.model, "is_contact_associable_model", False):
+                for generic_filter_test in (
+                    ["contacts", "associated_contacts__contact__name"],
+                    ["contacts", "associated_contacts__contact__id"],
+                    ["teams", "associated_contacts__team__name"],
+                    ["teams", "associated_contacts__team__id"],
+                ):
+                    if generic_filter_test not in self.generic_filter_tests:
+                        self.generic_filter_tests = (*self.generic_filter_tests, generic_filter_test)
+
+                # Make sure we have some valid contact-associations:
+                for contact, team, instance in zip(Contact.objects.all()[:3], Team.objects.all()[:3], self.queryset):
+                    ContactAssociation.objects.create(
+                        contact=contact,
+                        associated_object=instance,
+                        role=Role.objects.get_for_model(ContactAssociation).first(),
+                        status=Status.objects.get_for_model(ContactAssociation).first(),
+                    )
+                    ContactAssociation.objects.create(
+                        team=team,
+                        associated_object=instance,
+                        role=Role.objects.get_for_model(ContactAssociation).last(),
+                        status=Status.objects.get_for_model(ContactAssociation).last(),
+                    )
+
             if not self.generic_filter_tests:
                 self.skipTest("No generic_filter_tests defined?")
 
@@ -147,11 +175,11 @@ class FilterTestCases:
                 field_name = filter_object.field_name
                 with self.subTest(f"{self.filterset.__name__} RelatedMembershipBooleanFilter {filter_name} (True)"):
                     filterset_result = self.filterset({filter_name: True}, self.queryset).qs
-                    qs_result = self.queryset.filter(**{f"{field_name}__isnull": False}).distinct()
+                    qs_result = self.queryset.filter(**{f"{field_name}__isnull": filter_object.exclude}).distinct()
                     self.assertQuerysetEqualAndNotEmpty(filterset_result, qs_result)
                 with self.subTest(f"{self.filterset.__name__} RelatedMembershipBooleanFilter {filter_name} (False)"):
                     filterset_result = self.filterset({filter_name: False}, self.queryset).qs
-                    qs_result = self.queryset.filter(**{f"{field_name}__isnull": True}).distinct()
+                    qs_result = self.queryset.exclude(**{f"{field_name}__isnull": filter_object.exclude}).distinct()
                     self.assertQuerysetEqualAndNotEmpty(filterset_result, qs_result)
 
         def test_tags_filter(self):
@@ -164,8 +192,16 @@ class FilterTestCases:
                 if len(instance.tags.all()) >= 2:
                     tags = list(instance.tags.all()[:2])
                     break
+
+            # Otherwise, create some tags and apply to an instance for this test
             else:
-                self.fail(f"Couldn't find any {self.queryset.model._meta.object_name} with at least two Tags.")
+                model_ct = ContentType.objects.get_for_model(self.queryset.model)
+                test_tags_filter_a = Tag.objects.get_or_create(name="test tags filter a")[0]
+                test_tags_filter_a.content_types.add(model_ct)
+                test_tags_filter_b = Tag.objects.get_or_create(name="test tags filter b")[0]
+                test_tags_filter_b.content_types.add(model_ct)
+                self.queryset.first().tags.add(test_tags_filter_a, test_tags_filter_b)
+                tags = [test_tags_filter_a, test_tags_filter_b]
             params = {"tags": [tags[0].name, tags[1].pk]}
             filterset_result = self.filterset(params, self.queryset).qs
             # Tags is an AND filter not an OR filter
@@ -222,22 +258,23 @@ class FilterTestCases:
             """
             self._assert_valid_filter_predicates(obj, obj_field_name)
 
-            # Create random 5 char string to append to attribute, used for icontains partial lookup
-            lookup = "".join(random.choices(string.ascii_lowercase, k=5))  # noqa: S311 # pseudo-random generator
-            obj_field_value = getattr(obj, obj_field_name)
+            # Generic test only supports CharField or TextFields, skip all other types
+            obj_field = obj._meta.get_field(obj_field_name)
+            if not isinstance(obj_field, (CharField, TextField)):
+                self.skipTest("Not a CharField or TextField")
 
-            if isinstance(obj_field_value, str):
-                updated_attr = obj_field_value + lookup
-                setattr(obj, obj_field_name, updated_attr)
-            else:
-                # Skip the test if the field is not a CharField, as we currently only support generic testing for CharField
-                self.skipTest("Not a CharField")
+            # 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 = updated_attr
+                lookup = randomized_attr_value.upper()
                 model_queryset = self.queryset.filter(**{f"{filter_field_name}": 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)
@@ -247,6 +284,7 @@ class FilterTestCases:
                 filterset_result.qs,
                 model_queryset,
                 ordered=False,
+                msg=lookup,
             )
 
         def _get_relevant_filterset_queryset(self, queryset, *filter_params):

nautobot/core/testing/mixins.py

@@ -6,8 +6,10 @@ from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
 from django.core.cache import cache
 from django.core.exceptions import FieldDoesNotExist
+from django.db import connections, DEFAULT_DB_ALIAS
 from django.db.models import JSONField, ManyToManyField, ManyToManyRel
 from django.forms.models import model_to_dict
+from django.test.utils import CaptureQueriesContext
 from netaddr import IPNetwork
 from rest_framework.test import APIClient, APIRequestFactory
 
@@ -44,6 +46,7 @@ class NautobotTestCaseMixin:
 
     user_permissions = ()
     client_class = NautobotTestClient
+    maxDiff = None
 
     def setUpNautobot(self, client=True, populate_status=False):
         """Setup shared testuser, statuses and client."""
@@ -231,6 +234,49 @@ class NautobotTestCaseMixin:
 
         return self.assertQuerysetEqual(qs, values, *args, **kwargs)
 
+    class _AssertApproximateNumQueriesContext(CaptureQueriesContext):
+        """Implementation class underlying the assertApproximateNumQueries decorator/context manager."""
+
+        def __init__(self, test_case, minimum, maximum, connection):
+            self.test_case = test_case
+            self.minimum = minimum
+            self.maximum = maximum
+            super().__init__(connection)
+
+        def __exit__(self, exc_type, exc_value, traceback):
+            super().__exit__(exc_type, exc_value, traceback)
+            if exc_type is not None:
+                return
+            num_queries = len(self)
+            captured_queries_string = "\n".join(
+                f"{i}. {query['sql']}" for i, query in enumerate(self.captured_queries, start=1)
+            )
+            self.test_case.assertGreaterEqual(
+                num_queries,
+                self.minimum,
+                f"{num_queries} queries executed, but expected at least {self.minimum}.\n"
+                f"Captured queries were:\n{captured_queries_string}",
+            )
+            self.test_case.assertLessEqual(
+                num_queries,
+                self.maximum,
+                f"{num_queries} queries executed, but expected no more than {self.maximum}.\n"
+                f"Captured queries were:\n{captured_queries_string}",
+            )
+
+    def assertApproximateNumQueries(self, minimum, maximum, func=None, *args, using=DEFAULT_DB_ALIAS, **kwargs):
+        """Like assertNumQueries, but fuzzier. Assert that the number of queries falls within an acceptable range."""
+        conn = connections[using]
+
+        context = self._AssertApproximateNumQueriesContext(self, minimum, maximum, conn)
+        if func is None:
+            return context
+
+        with context:
+            func(*args, **kwargs)
+
+        return None
+
     #
     # Convenience methods
     #

nautobot/core/testing/models.py

@@ -1,7 +1,9 @@
+from django.db.models import QuerySet
 from django.test import tag, TestCase
 
 from nautobot.core.templatetags.helpers import get_docs_url
 from nautobot.core.testing.mixins import NautobotTestCaseMixin
+from nautobot.extras.models import DynamicGroup, StaticGroupAssociation
 
 
 @tag("unit")
@@ -41,3 +43,23 @@ class ModelTestCases:
         def test_get_docs_url(self):
             """Check that `get_docs_url()` returns a valid static file path for this model."""
             self.assertIsNotNone(get_docs_url(self.model))
+
+        def test_dynamic_group_api(self):
+            """For dynamic-group capable models, check that they work as intended."""
+            if not getattr(self.model, "is_dynamic_group_associable_model", False):
+                self.skipTest("Not a dynamic group associable model.")
+
+            self.assertTrue(hasattr(self.model, "dynamic_groups"))
+            self.assertIsInstance(self.model.objects.first().dynamic_groups, QuerySet)
+            self.assertEqual(self.model.objects.first().dynamic_groups.model, DynamicGroup)
+
+            if DynamicGroup.objects.get_for_model(self.model).exists():
+                dg = DynamicGroup.objects.get_for_model(self.model).first()
+                self.assertEqual(dg.members.model, self.model)
+
+            # Models using DynamicGroupMixin w/o DynamicGroupsModelMixin will not have static_group_association_set
+            if hasattr(self.model, "static_group_association_set"):
+                self.assertIsInstance(self.model.objects.first().static_group_association_set.all(), QuerySet)
+                self.assertEqual(
+                    self.model.objects.first().static_group_association_set.all().model, StaticGroupAssociation
+                )

nautobot/core/testing/schema.py

@@ -1,10 +1,7 @@
-from io import StringIO
-
 from django.conf import settings
-from django.core.management import call_command
 from django.test import tag
+from drf_spectacular.settings import spectacular_settings
 from rest_framework.settings import api_settings
-import yaml
 
 from nautobot.core.testing import views
 
@@ -19,11 +16,10 @@ class OpenAPISchemaTestCases:
             # We could load the schema from the /api/swagger.yaml endpoint in setUp(self) via self.client,
             # but it's fairly expensive to do so. Better to do so only once per class.
             cls.schemas = {}
+            generator_class = spectacular_settings.DEFAULT_GENERATOR_CLASS
             for api_version in api_settings.ALLOWED_VERSIONS:
-                out = StringIO()
-                err = StringIO()
-                call_command("spectacular", "--api-version", api_version, stdout=out, stderr=err)
-                cls.schemas[api_version] = yaml.safe_load(out.getvalue())
+                generator = generator_class(api_version=api_version)
+                cls.schemas[api_version] = generator.get_schema(request=None, public=True)
 
         def get_component_schema(self, component_name, api_version=None):
             """Helper method to pull a specific component schema from the larger OpenAPI schema already loaded."""