nautobot 2.3.15b1__py3-none-any.whl → 2.4.0__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,13 +15,14 @@ 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.extras.registry import registry
 from nautobot.ipam import models as ipam_models
 
 from example_app.models import ExampleModel
@@ -66,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):
     """
@@ -882,22 +896,6 @@ class MergeDictsWithoutCollisionTest(TestCase):
         self.assertEqual(str(err.exception), 'Conflicting values for key "a": (1, 2)')
 
 
-class NavigationRelatedUtils(TestCase):
-    def get_all_new_ui_ready_route(self):
-        ui_ready_routes = [
-            "^\\Z",
-            "^dcim/device\\-types/(?P<pk>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/\\Z",
-            "^dcim/device\\-types/\\Z",
-            "^dcim/devices/(?P<pk>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/\\Z",
-            "^dcim/devices/\\Z",
-            "^dcim/locations/(?P<pk>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/\\Z",
-            "^dcim/locations/\\Z",
-            "^ipam/ip\\-addresses/(?P<pk>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/\\Z",
-            "^ipam/ip\\-addresses/\\Z",
-        ]
-        self.assertEqual(sorted(ui_ready_routes), sorted(list(registry["new_ui_ready_routes"])))
-
-
 class TestMigrationUtils(TestCase):
     def test_update_object_change_ct_for_replaced_models(self):
         """Assert update and update reverse of ObjectChange"""
@@ -933,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

@@ -1,3 +1,4 @@
+import json
 import re
 from unittest import mock, skipIf
 import urllib.parse
@@ -11,19 +12,22 @@ from django.test.utils import override_script_prefix
 from django.urls import get_script_prefix, reverse
 from prometheus_client.parser import text_string_to_metric_families
 
+from nautobot.circuits.models import Circuit, CircuitType, Provider
 from nautobot.core.constants import GLOBAL_SEARCH_EXCLUDE_LIST
 from nautobot.core.testing import TestCase
 from nautobot.core.testing.api import APITestCase
+from nautobot.core.testing.context import load_event_broker_override_settings
 from nautobot.core.testing.utils import extract_page_body
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.core.views import NautobotMetricsView
 from nautobot.core.views.mixins import GetReturnURLMixin
 from nautobot.dcim.models.locations import Location
 from nautobot.extras.choices import CustomFieldTypeChoices
-from nautobot.extras.models import FileProxy
+from nautobot.extras.models import FileProxy, Status
 from nautobot.extras.models.customfields import CustomField, CustomFieldChoice
 from nautobot.extras.registry import registry
 from nautobot.users.models import ObjectPermission
+from nautobot.users.utils import serialize_user_without_config_and_views
 
 
 class GetReturnURLMixinTestCase(TestCase):
@@ -318,8 +322,29 @@ class NavAppsUITestCase(TestCase):
     def setUp(self):
         super().setUp()
 
-        self.url = reverse("apps:apps_list")
-        self.item_weight = 100  # TODO: not easy to introspect from the nav menu struct, so hard-code it here for now
+        self.apps_marketplace_url = reverse("apps:apps_marketplace")
+        self.apps_marketplace_item_weight = (
+            100  # TODO: not easy to introspect from the nav menu struct, so hard-code it here for now
+        )
+
+        self.apps_list_url = reverse("apps:apps_list")
+        self.apps_list_item_weight = (
+            200  # TODO: not easy to introspect from the nav menu struct, so hard-code it here for now
+        )
+
+    def test_apps_marketplace_visible(self):
+        """The "Apps Marketplace" menu item should be available to an authenticated user regardless of permissions."""
+        response = self.client.get(reverse("home"))
+        self.assertContains(
+            response,
+            f"""
+            <a href="{self.apps_marketplace_url}"
+                data-item-weight="{self.apps_marketplace_item_weight}">
+                Apps Marketplace
+            </a>
+            """,
+            html=True,
+        )
 
     def test_installed_apps_visible(self):
         """The "Installed Apps" menu item should be available to an authenticated user regardless of permissions."""
@@ -327,8 +352,8 @@ class NavAppsUITestCase(TestCase):
         self.assertContains(
             response,
             f"""
-            <a href="{self.url}"
-                data-item-weight="{self.item_weight}">
+            <a href="{self.apps_list_url}"
+                data-item-weight="{self.apps_list_item_weight}">
                 Installed Apps
             </a>
             """,
@@ -398,6 +423,52 @@ class LoginUITestCase(TestCase):
             response = self.client.get(url)
             self.assertHttpStatus(response, 403)
 
+    @load_event_broker_override_settings(
+        EVENT_BROKERS={
+            "SyslogEventBroker": {
+                "CLASS": "nautobot.core.events.SyslogEventBroker",
+                "TOPICS": {
+                    "INCLUDE": ["*"],
+                },
+            }
+        }
+    )
+    def test_login_logout(self):
+        self.client.logout()
+        self.user.set_password("pass")
+        self.user.save()
+
+        with self.assertLogs("nautobot.events") as cm:
+            self.client.post(
+                reverse("login"),
+                data={
+                    "username": self.user.username,
+                    "password": "pass",
+                },
+            )
+        self.user.refresh_from_db()
+        payload = serialize_user_without_config_and_views(self.user)
+        self.assertEqual(
+            cm.output,
+            [f"INFO:nautobot.events.nautobot.users.user.login:{json.dumps(payload, indent=4)}"],
+        )
+        self.assertTrue(self.user.is_authenticated)
+        self.assertNotIn("password", cm.output)
+        self.assertNotIn("pass", cm.output)
+
+        with self.assertLogs("nautobot.events") as cm:
+            self.client.get(
+                reverse("logout"),
+            )
+        self.user.refresh_from_db()
+        payload = serialize_user_without_config_and_views(self.user)
+        self.assertEqual(
+            cm.output,
+            [f"INFO:nautobot.events.nautobot.users.user.logout:{json.dumps(payload, indent=4)}"],
+        )
+        self.assertNotIn("password", cm.output)
+        self.assertNotIn("pass", cm.output)
+
 
 class MetricsViewTestCase(TestCase):
     def query_and_parse_metrics(self):
@@ -594,3 +665,80 @@ class ExampleViewWithCustomPermissionsTest(TestCase):
         self.user.save()
         response = self.client.get(url)
         self.assertBodyContains(response, "You are viewing a table of example models")
+
+
+class TestObjectDetailView(TestCase):
+    @override_settings(PAGINATE_COUNT=5)
+    def test_object_table_panel(self):
+        provider = Provider.objects.create(name="A Test Provider 1")
+        circuit_type = CircuitType.objects.create(
+            name="A Test Circuit Type",
+        )
+        circuit_status = Status.objects.get_for_model(Circuit).first()
+
+        circuits = [
+            Circuit(
+                provider=provider,
+                cid=f"00121{x}",
+                circuit_type=circuit_type,
+                status=circuit_status,
+            )
+            for x in range(10)
+        ]
+        Circuit.objects.bulk_create(circuits)
+
+        self.add_permissions("circuits.view_provider", "circuits.view_circuit")
+        url = reverse("circuits:provider", args=(provider.pk,))
+        response = self.client.get(f"{url}?tab=main")
+        self.assertHttpStatus(response, 200)
+        response_data = response.content.decode(response.charset)
+        view_move_url = reverse("circuits:circuit_list") + f"?provider={provider.id}"
+
+        # Assert Badge Count in table panel header
+        panel_header = f"""<div class="panel-heading"><strong>Circuits</strong> <a href="{view_move_url}" class="badge badge-primary">10</a></div>"""
+        self.assertInHTML(panel_header, response_data)
+
+        # Assert view X more btn
+        view_more_btn = f"""<a href="{view_move_url}"><span class="mdi mdi-dots-horizontal" aria-hidden="true"></span>View 5 more circuits</a>"""
+        self.assertInHTML(view_more_btn, response_data)
+
+        # Validate Copy btn on all rows excluding empty rows
+        name_copy = f"""
+        <span class="hover_copy">
+            <span id="_value_name">{provider.name}</span>
+            <button class="btn btn-inline btn-default hover_copy_button" data-clipboard-target="#_value_name">
+                <span class="mdi mdi-content-copy"></span>
+            </button>
+        </span>"""
+        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/base.py

@@ -0,0 +1,11 @@
+"""Common base classes and utilities for defining the Nautobot UI."""
+
+
+class PermissionsMixin:
+    """Ensure permissions through init."""
+
+    def __init__(self, permissions=None):
+        """Ensure permissions."""
+        if permissions is not None and not isinstance(permissions, (list, tuple)):
+            raise TypeError("Permissions must be passed as a tuple or list.")
+        self.permissions = set(permissions) if permissions else None

nautobot/core/ui/choices.py

@@ -0,0 +1,44 @@
+"""ChoiceSets for Nautobot UI Framework."""
+
+from nautobot.core.choices import ChoiceSet
+
+
+class LayoutChoices(ChoiceSet):
+    """Page (or more properly tab) column layout choices.
+
+    Attributes:
+        TWO_OVER_ONE (str): Half-width panels will be above full-width panels (value: 2-over-1)
+        ONE_OVER_TWO (str): Full-width panels will be above half-width panels (value: 1-over-2)
+
+        DEFAULT (str): Two columns of half-width panels on top; full-width panels below. (value of TWO_OVER_ONE)
+    """
+
+    TWO_OVER_ONE = "2-over-1"
+    ONE_OVER_TWO = "1-over-2"
+
+    DEFAULT = TWO_OVER_ONE
+
+    CHOICES = (
+        (TWO_OVER_ONE, "Two Columns over One Column"),
+        (ONE_OVER_TWO, "One Column over Two Columns"),
+    )
+
+
+class SectionChoices(ChoiceSet):
+    """Sections of a Layout to assign panels to. Placement of panels is determined by [`LayoutChoices`](./ui.md#nautobot.apps.ui.LayoutChoices) set on `Tab.layout`
+
+    Attributes:
+        LEFT_HALF (str): Left side, half-width (value: left-half)
+        RIGHT_HALF (str): Right side, half-width (value: right-half)
+        FULL_WIDTH (str): Full width (value: full-width)
+    """
+
+    LEFT_HALF = "left-half"
+    RIGHT_HALF = "right-half"
+    FULL_WIDTH = "full-width"
+
+    CHOICES = (
+        (LEFT_HALF, "Left half of page"),
+        (RIGHT_HALF, "Right half of page"),
+        (FULL_WIDTH, "Full width of page"),
+    )

nautobot/core/ui/homepage.py

@@ -0,0 +1,167 @@
+"""Base classes and utilities for defining the Nautobot home page."""
+
+from abc import ABC, abstractmethod
+
+from .base import PermissionsMixin
+
+
+class HomePageBase(ABC):
+    """Base class for homepage layout classes."""
+
+    @property
+    @abstractmethod
+    def initial_dict(self):  # to be implemented by each subclass
+        return {}
+
+    @property
+    @abstractmethod
+    def fixed_fields(self):  # to be implemented by subclass
+        return ()
+
+
+class HomePagePanel(HomePageBase, PermissionsMixin):
+    """Defines properties that can be used for a panel."""
+
+    items = None
+    template_path = None
+
+    @property
+    def initial_dict(self):
+        return {
+            "custom_template": self.custom_template,
+            "custom_data": self.custom_data,
+            "weight": self.weight,
+            "items": {},
+            "permissions": self.permissions,
+            "template_path": self.template_path,
+        }
+
+    @property
+    def fixed_fields(self):
+        return ()
+
+    def __init__(self, name, permissions=None, custom_data=None, custom_template=None, items=None, weight=1000):
+        """
+        Ensure panel properties.
+
+        Args:
+            name (str): The name of the panel.
+            permissions (list): The permissions required to view this panel.
+            custom_data (dict): Custom data to be passed to the custom template.
+            custom_template (str): Name of custom template.
+            items (list): List of items to be rendered in this panel.
+            weight (int): The weight of this panel.
+        """
+        super().__init__(permissions)
+        self.custom_data = custom_data
+        self.custom_template = custom_template
+        self.name = name
+        self.weight = weight
+
+        if items is not None and custom_template is not None:
+            raise ValueError("Cannot specify items and custom_template at the same time.")
+        if items is not None:
+            if not isinstance(items, (list, tuple)):
+                raise TypeError("Items must be passed as a tuple or list.")
+            elif not all(isinstance(item, (HomePageGroup, HomePageItem)) for item in items):
+                raise TypeError("All items defined in a panel must be an instance of HomePageGroup or HomePageItem")
+            self.items = items
+        else:
+            self.items = []
+
+
+class HomePageGroup(HomePageBase, PermissionsMixin):
+    """Defines properties that can be used for a panel group."""
+
+    items = []
+
+    @property
+    def initial_dict(self):
+        return {
+            "items": {},
+            "permissions": self.permissions,
+            "weight": self.weight,
+        }
+
+    @property
+    def fixed_fields(self):
+        return ()
+
+    def __init__(self, name, permissions=None, items=None, weight=1000):
+        """
+        Ensure group properties.
+
+        Args:
+            name (str): The name of the group.
+            permissions (list): The permissions required to view this group.
+            items (list): List of items to be rendered in this group.
+            weight (int): The weight of this group.
+        """
+        super().__init__(permissions)
+        self.name = name
+        self.weight = weight
+
+        if items is not None:
+            if not isinstance(items, (list, tuple)):
+                raise TypeError("Items must be passed as a tuple or list.")
+            elif not all(isinstance(item, HomePageItem) for item in items):
+                raise TypeError("All items defined in a group must be an instance of HomePageItem")
+            self.items = items
+
+
+class HomePageItem(HomePageBase, PermissionsMixin):
+    """Defines properties that can be used for a panel item."""
+
+    items = []
+    template_path = None
+
+    @property
+    def initial_dict(self):
+        return {
+            "custom_template": self.custom_template,
+            "custom_data": self.custom_data,
+            "description": self.description,
+            "link": self.link,
+            "model": self.model,
+            "permissions": self.permissions,
+            "template_path": self.template_path,
+            "weight": self.weight,
+        }
+
+    @property
+    def fixed_fields(self):
+        return ()
+
+    def __init__(
+        self,
+        name,
+        link=None,
+        model=None,
+        custom_template=None,
+        custom_data=None,
+        description=None,
+        permissions=None,
+        weight=1000,
+    ):
+        """
+        Ensure item properties.
+
+        Args:
+            name (str): The name of the item.
+            link (str): The link to be used for this item.
+            model (str): The model to being used for this item to calculate the total count of objects.
+            custom_template (str): Name of custom template.
+            custom_data (dict): Custom data to be passed to the custom template.
+        """
+        super().__init__(permissions)
+
+        self.name = name
+        self.custom_template = custom_template
+        self.custom_data = custom_data
+        self.description = description
+        self.link = link
+        self.model = model
+        self.weight = weight
+
+        if model is not None and custom_template is not None:
+            raise ValueError("Cannot specify model and custom_template at the same time.")