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

nautobot/core/tests/test_utils.py

@@ -1,4 +1,3 @@
-from unittest import mock
 import uuid
 
 from django import forms as django_forms
@@ -15,13 +14,11 @@ 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, querysets, requests
+from nautobot.core.utils import data as data_utils, filtering, lookup, 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
 
@@ -68,18 +65,6 @@ 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):
     """
@@ -282,14 +267,6 @@ 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):
@@ -931,42 +908,3 @@ 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,7 +664,9 @@ class ExampleViewWithCustomPermissionsTest(TestCase):
         self.user.is_staff = True
         self.user.save()
         response = self.client.get(url)
-        self.assertBodyContains(response, "You are viewing a table of example models")
+        self.assertHttpStatus(response, 200)
+        response_body = response.content.decode(response.charset)
+        self.assertIn("You are viewing a table of example models", response_body)
 
 
 class TestObjectDetailView(TestCase):
@@ -713,32 +715,3 @@ 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,7 +119,6 @@ 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,21 +586,7 @@ 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).
-    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.
-    """
+    """A panel that renders a Table of objects (typically related objects, rather than the "main" object of a view)."""
 
     def __init__(
         self,

nautobot/core/urls.py

@@ -1,11 +1,9 @@
 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,
@@ -29,7 +27,6 @@ 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"),
@@ -79,14 +76,6 @@ 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/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, resolve, reverse, URLPattern, URLResolver
+from django.urls import get_resolver, 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, suffix=None):
+def get_table_for_model(model):
     """Return the `Table` class associated with a given `model`.
 
     The `Table` class is expected to be in the `tables` module within the application
@@ -223,12 +223,11 @@ def get_table_for_model(model, suffix=None):
 
     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=suffix or "Table")
+    return get_related_class_for_model(model, module_name="tables", object_suffix="Table")
 
 
 def get_view_for_model(model, view_type=""):
@@ -277,13 +276,11 @@ 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
     """
-
-    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__
+    model = get_model_for_view_name(view_name)
+    if model:
+        table_class = get_table_for_model(model)
+        if table_class:
+            return table_class.__name__
     return None
 
 

nautobot/core/utils/requests.py

@@ -141,35 +141,22 @@ def get_filterable_params_from_filter_params(filter_params, non_filter_params, f
     return final_filter_params
 
 
-def normalize_querydict(querydict, form_class=None, filterset=None):
+def normalize_querydict(querydict, form_class=None):
     """
-    Converts a QueryDict into a standard, mutable dictionary while preserving multiple values as lists.
+    Convert a QueryDict to a normal, mutable dictionary, preserving list values. For example,
 
-    Example:
-        A QueryDict like:
-            QueryDict('foo=1&bar=2&bar=3&baz=')
+        QueryDict('foo=1&bar=2&bar=3&baz=')
 
-        Converts to:
-            {'foo': '1', 'bar': ['2', '3'], 'baz': ''}
+    becomes:
 
-    This function ensures that fields with multiple values are handled correctly, as QueryDict
-    does not inherently preserve multiple values as lists.
+        {'foo': '1', 'bar': ['2', '3'], 'baz': ''}
 
-    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")
+    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.
+    """
     result = {}
-
     if querydict:
         for key, value_list in querydict.lists():
             if len(value_list) > 1:
@@ -184,8 +171,6 @@ def normalize_querydict(querydict, form_class=None, filterset=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,5 +1,4 @@
 import contextlib
-import datetime
 import logging
 import os
 import platform
@@ -46,7 +45,6 @@ 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
@@ -482,46 +480,6 @@ 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."""