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

nautobot/core/tests/test_utils.py

@@ -1,3 +1,4 @@
+from unittest import mock
 import uuid
 
 from django import forms as django_forms
@@ -14,11 +15,13 @@ from nautobot.core.api import utils as api_utils
 from nautobot.core.forms.utils import compress_range
 from nautobot.core.models import fields as core_fields, utils as models_utils, validators
 from nautobot.core.testing import TestCase
-from nautobot.core.utils import data as data_utils, filtering, lookup, requests
+from nautobot.core.utils import data as data_utils, filtering, lookup, querysets, requests
 from nautobot.core.utils.migrations import update_object_change_ct_for_replaced_models
 from nautobot.dcim import filters as dcim_filters, forms as dcim_forms, models as dcim_models, tables
 from nautobot.extras import models as extras_models, utils as extras_utils
 from nautobot.extras.choices import ObjectChangeActionChoices, RelationshipTypeChoices
+from nautobot.extras.filters import StatusFilterSet
+from nautobot.extras.forms import StatusForm
 from nautobot.extras.models import ObjectChange
 from nautobot.ipam import models as ipam_models
 
@@ -65,6 +68,18 @@ class NormalizeQueryDictTest(TestCase):
             {"foo": "1", "bar": ["2", "3"], "baz": ""},
         )
 
+        self.assertDictEqual(
+            requests.normalize_querydict(QueryDict("name=Sample Status&content_types=1"), form_class=StatusForm),
+            {"name": "Sample Status", "content_types": ["1"]},
+        )
+
+        self.assertDictEqual(
+            requests.normalize_querydict(
+                QueryDict("name=Sample Status&content_types=dcim.device"), filterset=StatusFilterSet()
+            ),
+            {"name": ["Sample Status"], "content_types": ["dcim.device"]},
+        )
+
 
 class DeepMergeTest(TestCase):
     """
@@ -267,6 +282,14 @@ class GetFooForModelTest(TestCase):
                 lookup.get_model_for_view_name("unknown:plugins:example_app:examplemodel_list")
             self.assertEqual(str(err.exception), "Unexpected View Name: unknown:plugins:example_app:examplemodel_list")
 
+    def test_get_table_class_string_from_view_name(self):
+        # Testing UIViewSet
+        self.assertEqual(lookup.get_table_class_string_from_view_name("circuits:circuit_list"), "CircuitTable")
+        # Testing Legacy View
+        self.assertEqual(lookup.get_table_class_string_from_view_name("dcim:location_list"), "LocationTable")
+        # Testing unconventional table name
+        self.assertEqual(lookup.get_table_class_string_from_view_name("ipam:prefix_list"), "PrefixDetailTable")
+
 
 class IsTaggableTest(TestCase):
     def test_is_taggable_true(self):
@@ -908,3 +931,42 @@ class TestMigrationUtils(TestCase):
             )
             self.assertEqual(ObjectChange.objects.get(request_id=request_id).changed_object_type, location_ct)
             self.assertEqual(ObjectChange.objects.get(request_id=request_id).related_object_type, location_ct)
+
+
+class TestQuerySetUtils(TestCase):
+    def test_maybe_select_related(self):
+        # If possible, select_related should be called
+        queryset = ipam_models.IPAddress.objects.all()
+        with mock.patch.object(queryset, "select_related", wraps=queryset.select_related) as mock_select_related:
+            new_queryset = querysets.maybe_select_related(queryset, ["parent", "status"])
+            mock_select_related.assert_called_with("parent", "status")
+            self.assertIsNot(new_queryset, queryset)
+
+        # Case where it shouldn't be called
+        queryset = ipam_models.IPAddress.objects.values_list("host", flat=True)
+        with mock.patch.object(queryset, "select_related", wraps=queryset.select_related) as mock_select_related:
+            new_queryset = querysets.maybe_select_related(queryset, ["parent", "status"])
+            mock_select_related.assert_not_called()
+            self.assertIs(new_queryset, queryset)
+
+        # Another case where it shouldn't be called
+        queryset = ipam_models.IPAddress.objects.difference(ipam_models.IPAddress.objects.filter(ip_version=4))
+        with mock.patch.object(queryset, "select_related", wraps=queryset.select_related) as mock_select_related:
+            new_queryset = querysets.maybe_select_related(queryset, ["parent", "status"])
+            mock_select_related.assert_not_called()
+            self.assertIs(new_queryset, queryset)
+
+    def test_maybe_prefetch_related(self):
+        # If possible, prefetch_related should be called
+        queryset = ipam_models.IPAddress.objects.all()
+        with mock.patch.object(queryset, "prefetch_related", wraps=queryset.prefetch_related) as mock_prefetch_related:
+            new_queryset = querysets.maybe_prefetch_related(queryset, ["nat_outside_list"])
+            mock_prefetch_related.assert_called_with("nat_outside_list")
+            self.assertIsNot(new_queryset, queryset)
+
+        # Case where it shouldn't be called
+        queryset = ipam_models.IPAddress.objects.difference(ipam_models.IPAddress.objects.filter(ip_version=4))
+        with mock.patch.object(queryset, "prefetch_related", wraps=queryset.prefetch_related) as mock_prefetch_related:
+            new_queryset = querysets.maybe_prefetch_related(queryset, ["nat_outside_list"])
+            mock_prefetch_related.assert_not_called()
+            self.assertIs(new_queryset, queryset)

nautobot/core/tests/test_views.py

@@ -664,9 +664,7 @@ class ExampleViewWithCustomPermissionsTest(TestCase):
         self.user.is_staff = True
         self.user.save()
         response = self.client.get(url)
-        self.assertHttpStatus(response, 200)
-        response_body = response.content.decode(response.charset)
-        self.assertIn("You are viewing a table of example models", response_body)
+        self.assertBodyContains(response, "You are viewing a table of example models")
 
 
 class TestObjectDetailView(TestCase):
@@ -715,3 +713,32 @@ class TestObjectDetailView(TestCase):
         self.assertInHTML(name_copy, response_data)
         # ASN do not have a value, therefore no copy btn
         self.assertNotIn("#asn_copy", response_data)
+
+
+class SearchRobotsTestCase(TestCase):
+    def test_robots_disallowed(self):
+        """
+        Test that the robots.txt file is accessible to all users and defaults to disallowing all bots.
+        """
+        url = reverse("robots_txt")
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 200)
+        self.assertBodyContains(response, "User-Agent: *")
+        self.assertBodyContains(response, "Disallow: /")
+
+        url = reverse("home")
+        response = self.client.get(url)
+        self.assertContains(response, '<meta name="robots" content="noindex, nofollow">', html=True)
+
+    @override_settings(PUBLISH_ROBOTS_TXT=False)
+    def test_robots_allowed(self):
+        """
+        Test that the robots.txt file is not published if PUBLISH_ROBOTS_TXT is set to False.
+        """
+        url = reverse("robots_txt")
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 404)
+
+        url = reverse("home")
+        response = self.client.get(url)
+        self.assertNotContains(response, '<meta name="robots" content="noindex, nofollow">', html=True)

nautobot/core/ui/nav.py

@@ -119,6 +119,7 @@ class NavMenuGroup(NavMenuBase, PermissionsMixin):
         elif not all(isinstance(item, NavMenuItem) for item in items):
             raise TypeError("All items defined in a group must be an instance of NavMenuItem")
         self.items = items
+        super().__init__(permissions=self.permissions)
 
 
 class NavMenuItem(NavMenuBase, PermissionsMixin):

nautobot/core/ui/object_detail.py

@@ -586,7 +586,21 @@ class DataTablePanel(Panel):
 
 
 class ObjectsTablePanel(Panel):
-    """A panel that renders a Table of objects (typically related objects, rather than the "main" object of a view)."""
+    """A panel that renders a Table of objects (typically related objects, rather than the "main" object of a view).
+    Has built-in pagination support and "Add" button at bottom of the Table.
+
+    It renders the django-tables2 classes with Nautobot additions. You can pass the instance of Table Class
+    already configured in context and set the `context_table_key` or pass a Table Class to `__init__` via `table_class`.
+
+    When `table_class` is set, you need to pass `table_filter` or `table_attribute` for fetching data purpose.
+
+    Data fetching can be optimized by using `select_related_fields`, `prefetch_related_fields`.
+
+    How Table is displayed can be changed by using `include_columns`, `exclude_columns`, `table_title`,
+    `hide_hierarchy_ui`, `related_field_name` or `enable_bulk_actions`.
+
+    Please check the Args list for further details.
+    """
 
     def __init__(
         self,

nautobot/core/urls.py

@@ -1,9 +1,11 @@
 from django.conf import settings
+from django.http import HttpResponse, HttpResponseNotFound
 from django.urls import include, path
 from django.views.generic import TemplateView
 from django.views.static import serve
 
 from nautobot.core.views import (
+    AboutView,
     CustomGraphQLView,
     get_file_with_authorization,
     HomeView,
@@ -27,6 +29,7 @@ from .admin import admin_site
 urlpatterns = [
     # Base views
     path("", HomeView.as_view(), name="home"),
+    path("about/", AboutView.as_view(), name="about"),
     path("search/", SearchView.as_view(), name="search"),
     # Login/logout
     path("login/", LoginView.as_view(), name="login"),
@@ -76,6 +79,14 @@ urlpatterns = [
     path(
         "template.css", TemplateView.as_view(template_name="template.css", content_type="text/css"), name="template_css"
     ),
+    # The response is conditional as opposed to wrapping the path() call in an if statement to be able to test the setting with current test setup
+    path(
+        "robots.txt",
+        lambda x: HttpResponse("User-Agent: *\nDisallow: /", content_type="text/plain")
+        if settings.PUBLISH_ROBOTS_TXT
+        else HttpResponseNotFound(),
+        name="robots_txt",
+    ),
 ]
 
 

nautobot/core/utils/git.py

@@ -57,7 +57,7 @@ class BranchDoesNotExist(Exception):
 
 
 class GitRepo:
-    def __init__(self, path, url, clone_initially=True):
+    def __init__(self, path, url, clone_initially=True, branch=None, depth=0):
         """
         Ensure that we have a clone of the given remote Git repository URL at the given local directory path.
 
@@ -65,6 +65,8 @@ class GitRepo:
             path (str): path to git repo
             url (str): git repo url
             clone_initially (bool): True if the repo needs to be cloned
+            branch (str): branch to checkout
+            depth (int): depth of the clone
         """
         self.url = url
         self.sanitized_url = sanitize(url)
@@ -73,7 +75,10 @@ class GitRepo:
         elif clone_initially:
             # Don't log `url` as it may include authentication details.
             logger.debug("Cloning git repository to %s...", path)
-            self.repo = Repo.clone_from(url, to_path=path, env=GIT_ENVIRONMENT)
+            if not depth:
+                self.repo = Repo.clone_from(url, to_path=path, env=GIT_ENVIRONMENT, branch=branch)
+            else:
+                self.repo = Repo.clone_from(url, to_path=path, env=GIT_ENVIRONMENT, branch=branch, depth=depth)
         else:
             self.repo = Repo.init(path)
             self.repo.create_remote("origin", url=url)

nautobot/core/utils/lookup.py

@@ -8,7 +8,7 @@ from django.conf import settings
 from django.contrib.auth.models import Group
 from django.contrib.contenttypes.models import ContentType
 from django.db.models import Model
-from django.urls import get_resolver, URLPattern, URLResolver
+from django.urls import get_resolver, resolve, reverse, URLPattern, URLResolver
 from django.utils.module_loading import import_string
 from django.views.generic.base import RedirectView
 
@@ -213,7 +213,7 @@ def get_related_field_for_models(from_model, to_model):
     return matching_field
 
 
-def get_table_for_model(model):
+def get_table_for_model(model, suffix=None):
     """Return the `Table` class associated with a given `model`.
 
     The `Table` class is expected to be in the `tables` module within the application
@@ -223,11 +223,12 @@ def get_table_for_model(model):
 
     Args:
         model (BaseModel): A model class
+        suffix (str): A replacement suffix for the table name (e.g. `DetailTable`, such as to retrieve `FooDetailTable`)
 
     Returns:
         (Union[Table, None]): Either the `Table` class or `None`
     """
-    return get_related_class_for_model(model, module_name="tables", object_suffix="Table")
+    return get_related_class_for_model(model, module_name="tables", object_suffix=suffix or "Table")
 
 
 def get_view_for_model(model, view_type=""):
@@ -276,11 +277,13 @@ def get_table_class_string_from_view_name(view_name):
     Returns:
         table_class_name (String): The name of the model table class or None e.g. LocationTable, CircuitTable
     """
-    model = get_model_for_view_name(view_name)
-    if model:
-        table_class = get_table_for_model(model)
-        if table_class:
-            return table_class.__name__
+
+    view_func = resolve(reverse(view_name)).func
+    view_class = getattr(view_func, "cls", getattr(view_func, "view_class", None))
+    if hasattr(view_class, "table_class"):
+        return view_class.table_class.__name__
+    if hasattr(view_class, "table"):
+        return view_class.table.__name__
     return None
 
 

nautobot/core/utils/querysets.py

@@ -0,0 +1,64 @@
+import logging
+
+from django.db import NotSupportedError
+
+logger = logging.getLogger(__name__)
+
+
+def maybe_select_related(queryset, select_fields):
+    """Attempt to perform a select_related() on the given queryset, but fail gracefully if not permitted."""
+    model = queryset.model
+
+    # Django doesn't allow .select_related() on a QuerySet that had .values()/.values_list() applied, or
+    # one that has had union()/intersection()/difference() applied.
+    # We can detect and avoid these cases the same way that Django itself does.
+    if queryset._fields is not None:
+        logger.debug(
+            "NOT applying select_related(%s) to %s QuerySet as it includes .values()/.values_list()",
+            select_fields,
+            model.__name__,
+        )
+    elif queryset.query.combinator:
+        logger.debug(
+            "NOT applying select_related(%s) to %s QuerySet as it is a combinator query",
+            select_fields,
+            model.__name__,
+        )
+    else:
+        logger.debug("Applying .select_related(%s) to %s QuerySet", select_fields, model.__name__)
+        # Belt and suspenders - we should have avoided any error cases above, but be safe anyway:
+        try:
+            queryset = queryset.select_related(*select_fields)
+        except (TypeError, ValueError, NotSupportedError) as exc:
+            logger.warning(
+                "Unexpected error when trying to .select_related() on %s QuerySet: %s",
+                model.__name__,
+                exc,
+            )
+
+    return queryset
+
+
+def maybe_prefetch_related(queryset, prefetch_fields):
+    """Attempt to perform a select_related() on the given queryset, but fail gracefully if not permitted."""
+    model = queryset.model
+
+    if queryset.query.combinator:
+        logger.debug(
+            "NOT applying prefetch_related(%s) to %s QuerySet as it is a combinator query",
+            prefetch_fields,
+            model.__name__,
+        )
+    else:
+        logger.debug("Applying .prefetch_related(%s) to %s QuerySet", prefetch_fields, model.__name__)
+        # Belt and suspenders - we should have avoided any error cases above, but be safe anyway:
+        try:
+            queryset = queryset.prefetch_related(*prefetch_fields)
+        except (AttributeError, TypeError, ValueError, NotSupportedError) as exc:
+            logger.warning(
+                "Unexpected error when trying to .prefetch_related() on %s QuerySet: %s",
+                model.__name__,
+                exc,
+            )
+
+    return queryset

nautobot/core/utils/requests.py

@@ -141,22 +141,35 @@ def get_filterable_params_from_filter_params(filter_params, non_filter_params, f
     return final_filter_params
 
 
-def normalize_querydict(querydict, form_class=None):
+def normalize_querydict(querydict, form_class=None, filterset=None):
     """
-    Convert a QueryDict to a normal, mutable dictionary, preserving list values. For example,
+    Converts a QueryDict into a standard, mutable dictionary while preserving multiple values as lists.
 
-        QueryDict('foo=1&bar=2&bar=3&baz=')
+    Example:
+        A QueryDict like:
+            QueryDict('foo=1&bar=2&bar=3&baz=')
 
-    becomes:
+        Converts to:
+            {'foo': '1', 'bar': ['2', '3'], 'baz': ''}
 
-        {'foo': '1', 'bar': ['2', '3'], 'baz': ''}
+    This function ensures that fields with multiple values are handled correctly, as QueryDict
+    does not inherently preserve multiple values as lists.
 
-    This function is necessary because QueryDict does not provide any built-in mechanism which preserves multiple
-    values.
-
-    A `form_class` can be provided as a way to hint which query parameters should be treated as lists.
+    Args:
+        querydict (QueryDict): The QueryDict to be normalized.
+        form_class (forms.Form, optional): A form class to identify fields that should be treated as
+            lists (e.g., `MultipleChoiceField` or `ModelMultipleChoiceField`).
+        filterset (django_filters.FilterSet, optional): A FilterSet instance to identify filters that
+            should preserve multiple values as lists (e.g., non-single-choice fields).
+
+    Raises:
+        AttributeError: If both `form_class` and `filterset` are provided.
     """
+    if form_class and filterset:
+        raise AttributeError("Either form_class or filterset_class is to be provided not both")
+
     result = {}
+
     if querydict:
         for key, value_list in querydict.lists():
             if len(value_list) > 1:
@@ -171,6 +184,8 @@ def normalize_querydict(querydict, form_class=None):
             ):
                 # Even though there's only a single value in the querydict for this key, the form wants it as a list
                 result[key] = value_list
+            elif filterset is not None and filterset.filters.get(key) and not is_single_choice_field(filterset, key):
+                result[key] = value_list
             else:
                 # Only a single value in the querydict for this key, and no guidance otherwise, so make it single
                 result[key] = value_list[0]

nautobot/core/views/__init__.py

@@ -1,4 +1,5 @@
 import contextlib
+import datetime
 import logging
 import os
 import platform
@@ -45,6 +46,7 @@ from nautobot.core.celery import app
 from nautobot.core.constants import SEARCH_MAX_RESULTS
 from nautobot.core.forms import SearchForm
 from nautobot.core.releases import get_latest_release
+from nautobot.core.utils.config import get_settings_or_config
 from nautobot.core.utils.lookup import get_route_for_model
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.extras.forms import GraphQLQueryForm
@@ -480,6 +482,46 @@ def get_file_with_authorization(request, *args, **kwargs):
     return get_file(request, *args, **kwargs)
 
 
+class AboutView(AccessMixin, TemplateView):
+    """
+    Nautobot About View which displays general information about Nautobot and contact details
+    for Network to Code.
+    """
+
+    template_name = "about.html"
+
+    def get(self, request, *args, **kwargs):
+        # Redirect user to login page if not authenticated
+        if not request.user.is_authenticated:
+            return self.handle_no_permission()
+        # Check whether a new release is available. (Only for staff/superusers.)
+        new_release = None
+        if request.user.is_staff or request.user.is_superuser:
+            latest_release, release_url = get_latest_release()
+            if isinstance(latest_release, version.Version):
+                current_version = version.parse(settings.VERSION)
+                if latest_release > current_version:
+                    new_release = {
+                        "version": str(latest_release),
+                        "url": release_url,
+                    }
+
+        # Support contract state
+        support_expiration_date = get_settings_or_config("NTC_SUPPORT_CONTRACT_EXPIRATION_DATE")
+        support_contract_active = support_expiration_date and support_expiration_date >= datetime.date.today()
+
+        context = self.get_context_data()
+        context.update(
+            {
+                "new_release": new_release,
+                "support_contract_active": support_contract_active,
+                "support_expiration_date": support_expiration_date,
+            }
+        )
+
+        return self.render_to_response(context)
+
+
 class RenderJinjaView(LoginRequiredMixin, TemplateView):
     """Render a Jinja template with context data."""