nautobot 2.4.2__py3-none-any.whl → 2.4.4__py3-none-any.whl

nautobot/core/management/commands/generate_performance_test_endpoints.py

@@ -0,0 +1,271 @@
+from typing import Optional
+
+from django.apps import apps
+from django.conf import settings
+from django.core.management.base import BaseCommand
+from django.urls import get_resolver
+from django.utils.http import urlencode
+import yaml
+
+from nautobot.core.utils.lookup import get_model_for_view_name
+
+# List of view names that are excluded for various error responses
+EXCLUDED_VIEW_NAMES = [
+    "graphql-api",  # "Method \\"GET\\" not allowed."
+    "graphql",  # "Must provide query string."
+    "dcim-api:device-napalm",  # "No platform is configured for this device."
+    "dcim-api:connected-device-list",  # "Request must include \\"peer_device\\" and \\"peer_interface\\" filters."
+    "login",
+    "logout",
+]
+
+# List of reversed url name suffixes that are used to identify GET endpoints UI and API
+GET_ENDPOINT_SUFFIXES = ("_list", "_notes", "_changelog", "-detail", "-list", "-notes")
+
+
+class Command(BaseCommand):
+    """
+    Example usage: `nautobot-server generate_performance_test_endpoints > endpoints.yml`
+    """
+
+    help = "List all relevant performance test url patterns in Nautobot Core"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--output-file",
+            help="A file path string that specifies the output file to write the endpoints to.",
+        )
+
+    def handle(self, *args, **options):
+        # Get the URL resolver
+        url_patterns = get_resolver().url_patterns
+
+        # Group the urls by app names
+        self.app_name_to_urls = {}
+        self.app_name_to_urls["endpoints"] = {}
+        # Fetch and store the urls by app names in the dictionary
+        self.fetch_urls(url_patterns)
+        for view_name, url_patterns in self.app_name_to_urls["endpoints"].items():
+            # De-duplicate the URL patterns and sort them.
+            self.app_name_to_urls["endpoints"][view_name] = sorted(list(set(url_patterns)))
+
+        if filepath := options.get("output_file"):
+            # Output the endpoints to a yaml file
+            with open(filepath, "w") as outfile:
+                yaml.dump(self.app_name_to_urls, outfile, sort_keys=True)
+        else:
+            # Output the endpoints to the console
+            self.stdout.write(yaml.dump(self.app_name_to_urls, sort_keys=True))
+
+    def is_eligible_get_endpoint(self, view_name):
+        """
+        Check if the view is a GET endpoint and if it is eligible for performance testing.
+        """
+        if view_name not in EXCLUDED_VIEW_NAMES and (view_name.endswith(GET_ENDPOINT_SUFFIXES) or "_" not in view_name):
+            return True
+        return False
+
+    def append_urls_to_dict(self, url_pattern, model_class, view_name, is_api_endpoint=False):
+        """
+        URL patterns are stored in the dictionary in the following format:
+            - Any model detail view URL pattern that contains `<uuid:pk>` or `(?P<pk>[/.]+)` will have two endpoints:
+                - One with the `model_class.objects.first().pk`
+                - One with the `model_class.objects.last().pk`
+            - Any model list view URL pattern will have two endpoints:
+                - One with default pagination
+                - One with custom pagination (5 pages with <total_object_count//5> instances per page)
+            - Any generic endpoint like `core:home` will have one endpoint which is the URL pattern itself.
+        """
+        if not model_class:
+            # A generic endpoint like `core:home`
+            if view_name not in self.app_name_to_urls["endpoints"]:
+                self.app_name_to_urls["endpoints"][view_name] = []
+            self.app_name_to_urls["endpoints"][view_name].append(url_pattern)
+            return
+
+        # Handle detail view url patterns
+        total_count = len(model_class.objects.all())
+        if "_list" not in view_name and "-list" not in view_name:
+            # If the model class is found, then we know we are dealing with a model related endpoint
+            if total_count == 0:
+                # TODO handle the case where there is no instances of the model is found
+                self.stderr.write(f"Not enough instances of {model_class} found, need at least 1")
+                return
+
+            # Identify the placeholder for the uuid
+            replace_string = ""
+            if "<uuid:pk>" in url_pattern:
+                replace_string = "<uuid:pk>"
+            elif "(?P<pk>[/.]+)" in url_pattern:
+                replace_string = "(?P<pk>[/.]+)"
+
+            if replace_string:
+                # Replace the uuid with the actual uuid
+                if total_count == 1:
+                    # Case where there is only one instance of the model
+                    first_url_pattern = url_pattern.replace(replace_string, str(model_class.objects.first().pk))
+                    if view_name not in self.app_name_to_urls["endpoints"]:
+                        self.app_name_to_urls["endpoints"][view_name] = []
+                    self.app_name_to_urls["endpoints"][view_name].append(first_url_pattern)
+                else:
+                    # Case where there is more than one instance of the model
+                    first_url_pattern = url_pattern.replace(replace_string, str(model_class.objects.first().pk))
+                    second_url_pattern = url_pattern.replace(replace_string, str(model_class.objects.last().pk))
+                    if view_name not in self.app_name_to_urls["endpoints"]:
+                        self.app_name_to_urls["endpoints"][view_name] = []
+                    self.app_name_to_urls["endpoints"][view_name].append(first_url_pattern)
+                    self.app_name_to_urls["endpoints"][view_name].append(second_url_pattern)
+        # Handle list view url patterns
+        else:
+            if view_name not in self.app_name_to_urls["endpoints"]:
+                self.app_name_to_urls["endpoints"][view_name] = []
+            # One endpoint with default pagination
+            self.app_name_to_urls["endpoints"][view_name].append(url_pattern)
+            page_query_parameter = 5
+            per_page_query_parameter = total_count // page_query_parameter
+            if not is_api_endpoint:
+                query_params = urlencode(
+                    {
+                        "per_page": per_page_query_parameter,
+                        "page": page_query_parameter,
+                    }
+                )
+            else:
+                query_params = urlencode(
+                    {
+                        "limit": per_page_query_parameter,
+                        "offset": per_page_query_parameter * (page_query_parameter - 1),
+                    }
+                )
+            # One endpoint with non-default pagination
+            self.app_name_to_urls["endpoints"][view_name].append(url_pattern + f"?{query_params}")
+
+    def construct_view_name_and_url_pattern(self, pattern) -> tuple[Optional[str], Optional[str], bool]:
+        """
+        Args:
+            pattern (django.urls.resolvers.URLPattern): A URL pattern object.
+
+        Returns:
+            url_pattern (str): The URL pattern of the view.
+            view_name (str): The URL name of the view.
+            is_api_endpoint (bool): True if the endpoint is an API endpoint, False otherwise.
+        """
+        lookup_str_list = pattern.lookup_str.split(".")
+
+        # Determine if the endpoint belongs to a plugin
+        is_app = lookup_str_list[0] != "nautobot"
+        is_api_endpoint = "api" in lookup_str_list
+        # One of the nautobot apps: nautobot.circuits, nautobot.dcim, and etc. if not is_app
+        # One of the plugins: example_app, and etc. if is_app
+        app_name = lookup_str_list[0] if is_app else lookup_str_list[1]
+
+        model = pattern.default_args.get("model", None)
+        if model:
+            app_name = model._meta.app_label
+
+        # Retrieve the base URL for the app to be used in the URL pattern
+        app_config = apps.get_app_config(app_name)
+        base_url = app_config.base_url if hasattr(app_config, "base_url") else app_name
+
+        if app_name == "users" and pattern.name in ["login", "logout"]:
+            # No need to test the login and logout endpoints for performance testing
+            url_pattern = f"/{pattern.pattern}"  # /login, /logout
+            view_name = f"{pattern.name}"  # login, logout
+        elif app_name == "core":
+            # Handle the special case where a view exist in the core app
+            # but its url pattern and view name does not include the prefix "/core" or "core:"
+            # ['nautobot', 'core', "views", "HomeView"]
+            # ['nautobot', 'core', "api", "views", "APIRootView"]
+            if pattern.name in ["api-root", "api-status", "graphql-api"]:
+                is_api_endpoint = True
+                url_pattern = f"/api/{pattern.pattern}"  # /api/status
+                view_name = f"{pattern.name}"  # api-status
+            elif pattern.name in ["home", "about", "search", "worker-status", "graphql", "metrics"]:
+                url_pattern = f"/{pattern.pattern}"  # /home, /about, /search
+                view_name = f"{pattern.name}"  # home, about, search
+            else:
+                url_pattern = None
+                view_name = None
+        elif app_name == "extras" and "plugins" in lookup_str_list:
+            # Handle the special case first for Installed apps related view is nested under the extras app.
+            # ['nautobot', 'extras', 'plugins', 'views', 'InstalledAppsView']
+
+            # We need special case handling to determine if the endpoint is an api endpoint as well for this view
+            view_class_name = lookup_str_list[-1]
+            if "API" in view_class_name:
+                is_api_endpoint = True
+            apps_or_plugins = "plugins" if "plugins" in pattern.name else "apps"
+            if is_api_endpoint:
+                url_pattern = f"/api/{apps_or_plugins}/{pattern.pattern}"  # /api/apps/installed-apps
+                view_name = f"{apps_or_plugins}-api:{pattern.name}"  # apps-api:apps-list
+            else:
+                url_pattern = f"/{apps_or_plugins}/{pattern.pattern}"  # /apps/installed-apps
+                view_name = f"{apps_or_plugins}:{pattern.name}"  # apps:apps_list
+        elif is_api_endpoint:
+            if not is_app:
+                # One of the nautobot apps: nautobot.circuits, nautobot.dcim, and etc.
+                url_pattern = f"/api/{base_url}/{pattern.pattern}"  # /api/dcim/devices/
+                app_name = f"{app_name}-api"  # dcim-api
+                view_name = f"{app_name}:{pattern.name}"  # dcim-api:device-list
+            else:
+                api_app_name = f"{app_name}-api"  # example_app-api
+                view_name = (
+                    f"plugins-api:{api_app_name}:{pattern.name}"  # plugins-api:example_app-api:examplemodel-list
+                )
+                url_pattern = f"/api/plugins/{base_url}/{pattern.pattern}"  # /api/plugins/example-app/models/
+        else:
+            if not is_app:
+                url_pattern = f"/{base_url}/{pattern.pattern}"  # /dcim/devices/
+                view_name = f"{app_name}:{pattern.name}"  # dcim:device_list
+            else:
+                view_name = f"plugins:{app_name}:{pattern.name}"  # plugins:example_app:examplemodel_list
+                url_pattern = f"/plugins/{base_url}/{pattern.pattern}"  # /plugins/example-app/models/
+
+        return url_pattern, view_name, is_api_endpoint
+
+    def fetch_urls(self, url_patterns):
+        """
+        Store the URL patterns in the dictionary to output an .YAML file
+        The dictionary will have the following structure:
+        {
+            "endpoints": {
+                <app_name>:<view_name>: [
+                    <url_pattern_1>,
+                    <url_pattern_2>,
+                ],
+                dcim:device: [
+                    "/dcim/devices/cfbd447f-d563-4fac-bb75-bdda70ab4e80/",
+                    "/dcim/devices/38471bfe-0aca-4e09-b545-b0f90280fb66/",
+                ],
+                dcim-api:device-detail: [
+                    "/api/dcim/devices/cfbd447f-d563-4fac-bb75-bdda70ab4e80/",
+                    "/api/dcim/devices/38471bfe-0aca-4e09-b545-b0f90280fb66/",
+                ],
+                ...
+            },
+            ...
+        """
+        for pattern in url_patterns:
+            if hasattr(pattern, "url_patterns"):
+                # If it's a nested URL pattern, recursively list its URLs
+                self.fetch_urls(pattern.url_patterns)
+            else:
+                # Only fetch urls from relevant apps
+                if pattern.lookup_str.startswith(("nautobot.", *settings.PLUGINS)):
+                    url_pattern, view_name, is_api_endpoint = self.construct_view_name_and_url_pattern(pattern)
+                    # We do not need to test the ?format=<json,csv,api> endpoints and non-GET endpoints
+                    if (
+                        url_pattern is not None
+                        and "(?P<format>[a-z0-9]+)" not in url_pattern
+                        and "<drf_format_suffix:format>" not in url_pattern
+                        and self.is_eligible_get_endpoint(view_name)
+                    ):
+                        # Replace "^" and "$" from the url pattern
+                        url_pattern = url_pattern.replace("^", "").replace("$", "")
+                        # Retrieve the model class for the view name
+                        try:
+                            model_class = get_model_for_view_name(view_name)
+                        except ValueError:
+                            # In case it is a generic view like /home, /about, /search
+                            model_class = None
+                        self.append_urls_to_dict(url_pattern, model_class, view_name, is_api_endpoint)

nautobot/core/models/utils.py

@@ -112,7 +112,12 @@ def serialize_object(obj, extra=None, exclude=None):
 
     # Include any tags. Check for tags cached on the instance; fall back to using the manager.
     if is_taggable(obj):
-        tags = getattr(obj, "_tags", []) or obj.tags.all()
+        # Note that when upgrading from Nautobot 1.x to 2.0, this method may be called during data migrations,
+        # specifically ipam_0022 and dcim_0034, to create ObjectChange records.
+        # This can be problematic (see issue #6952) as the Tag records in the DB still have `created` as a `DateField`,
+        # but the 2.x code expects this to be a `DateTimeField` (as it will be after the upgrade completes in full).
+        # We "cleverly" bypass that issue by using `.only("name")` since that's the only actual Tag field we need here.
+        tags = getattr(obj, "_tags", []) or obj.tags.only("name")
         data["tags"] = [tag.name for tag in tags]
 
     # Append any extra data

nautobot/core/templates/generic/object_bulk_delete.html

@@ -1,2 +1,2 @@
 {% extends 'generic/object_bulk_destroy.html' %}
-{% comment %}2.0 TODO: remove this template, which only exists for backward compatibility with 1.3 and earlier{% endcomment %}
+{% comment %}3.0 TODO: remove this template, which only exists for backward compatibility with 2.4 and earlier{% endcomment %}

nautobot/core/templates/generic/object_bulk_edit.html

@@ -1,2 +1,2 @@
 {% extends 'generic/object_bulk_update.html' %}
-{% comment %}2.0 TODO: remove this template, which only exists for backward compatibility with 1.3 and earlier{% endcomment %}
+{% comment %}3.0 TODO: remove this template, which only exists for backward compatibility with 2.4 and earlier{% endcomment %}

nautobot/core/templates/generic/object_bulk_import.html

@@ -1,2 +1,2 @@
 {% extends 'generic/object_bulk_create.html' %}
-{% comment %}2.0 TODO: remove this template, which only exists for backward compatibility with 1.3 and earlier{% endcomment %}
+{% comment %}3.0 TODO: remove this template, which only exists for backward compatibility with 2.4 and earlier{% endcomment %}

nautobot/core/templates/generic/object_create.html

@@ -64,3 +64,8 @@
         </div>
     </form>
 {% endblock %}
+
+{% block javascript %}
+    {{ block.super }}
+    {{ form.media }}
+{% endblock %}

nautobot/core/templates/generic/object_delete.html

@@ -1,2 +1,2 @@
 {% extends 'generic/object_destroy.html' %}
-{% comment %}2.0 TODO: remove this template, which only exists for backward compatibility with 1.3 and earlier{% endcomment %}
+{% comment %}3.0 TODO: remove this template, which only exists for backward compatibility with 2.4 and earlier{% endcomment %}

nautobot/core/templates/generic/object_detail.html

@@ -1,2 +1,2 @@
 {% extends 'generic/object_retrieve.html' %}
-{% comment %}2.0 TODO: remove this template, which only exists for backward compatibility with 1.3 and earlier{% endcomment %}
+{% comment %}3.0 TODO: remove this template, which only exists for backward compatibility with 2.4 and earlier{% endcomment %}

nautobot/core/templates/generic/object_edit.html

@@ -1,2 +1,2 @@
 {% extends 'generic/object_create.html' %}
-{% comment %}2.0 TODO: remove this template, which only exists for backward compatibility with 1.3 and earlier{% endcomment %}
+{% comment %}3.0 TODO: remove this template, which only exists for backward compatibility with 2.4 and earlier{% endcomment %}

nautobot/core/templates/inc/javascript.html

@@ -24,7 +24,10 @@
         onerror="window.location='{% url 'media_failure' %}?filename=js/theme.js'"></script>
 <script src="{% versioned_static 'js/table_sorting_indicator.js' %}"
         onerror="window.location='{% url 'media_failure' %}?filename=js/table_sorting_indicator.js'"></script>
+<script src="{% versioned_static 'js/dropdown.js' %}"
+        onerror="window.location='{% url 'media_failure' %}?filename=js/dropdown.js'"></script>
 <script type="text/javascript">
+    var nautobot_static_url = "{% static '' %}";
     var nautobot_api_path = "{% url 'api-root' %}";
     var nautobot_csrf_token = "{{ csrf_token }}";
     var loading = $(".loading");

nautobot/core/templates/widgets/clearable_file.html

@@ -0,0 +1,5 @@
+{% if widget.is_initial %}{{ widget.initial_text }}: <a href="{{ widget.value.url }}">{{ widget.value }}</a>{% if not widget.required %}
+<input type="checkbox" name="{{ widget.checkbox_name }}" id="{{ widget.checkbox_id }}"{% if widget.attrs.disabled %} disabled{% endif %}{% if widget.attrs.checked %} checked{% endif %}>
+<label for="{{ widget.checkbox_id }}">{{ widget.clear_checkbox_label }}</label>{% endif %}<br>
+{{ widget.input_text }}:{% endif %}
+<input type="{{ widget.type }}" name="{{ widget.name }}" class="filestyle" data-placeholder="No file selected" {% include "django/forms/widgets/attrs.html" %}>

nautobot/core/templatetags/helpers.py

@@ -870,9 +870,7 @@ def saved_view_modal(
 ):
     from nautobot.extras.forms import SavedViewModalForm
     from nautobot.extras.models import SavedView
-
-    param_dict = {}
-    filters_applied = parse_qs(params)
+    from nautobot.extras.utils import fixup_filterset_query_params
 
     sort_order = []
     per_page = None
@@ -889,6 +887,8 @@ def saved_view_modal(
         "table_changes_pending",
         "clear_view",
     ]
+    param_dict = {}
+    filters_applied = fixup_filterset_query_params(parse_qs(params), view, non_filter_params)
 
     view_class = lookup.get_view_for_model(model, "List")
     table_name = None

nautobot/core/templatetags/ui_framework.py

@@ -1,9 +1,13 @@
+import logging
+
 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
 
+logger = logging.getLogger(__name__)
+
 register = template.Library()
 
 
@@ -26,15 +30,27 @@ def render_components(context, components):
 @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.
+    Render the "extra_buttons" from the context's object_detail_content, or as fallback, from the base detail view.
 
     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)
+    object_detail_content = context.get("object_detail_content")
+    if object_detail_content is None:
+        obj = get_obj_from_context(context)
+        if obj is None:
+            logger.error("No 'obj' or 'object' found in the render context!")
+            return ""
+        base_detail_view = get_view_for_model(obj)
+        if base_detail_view is None:
+            logger.warning(
+                "Unable to identify the base detail view - check that it has a valid name, i.e. %sUIViewSet or %sView",
+                type(obj).__name__,
+                type(obj).__name__,
+            )
+            return ""
+        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/forms.py

@@ -24,7 +24,7 @@ class FormTestCases:
                         self.skipTest(f"{self.form_class.__name__}.{field_name} has no query_params")
                     field_model = field_class.queryset.model
                     filterset_class = get_filterset_for_model(field_model)
-                    filterset_fields = set(filterset_class.declared_filters.keys())
+                    filterset_fields = set(filterset_class.get_filters().keys())
                     invalid_query_params = query_params_fields - filterset_fields
                     self.assertFalse(
                         invalid_query_params,

nautobot/core/testing/integration.py

@@ -86,6 +86,10 @@ class ObjectsListMixin:
         """
         self.click_button('#select_all_box button[name="_edit"]')
 
+    def click_table_link(self, row=1, column=2):
+        """By default, tries to click column next to checkbox to go to the details page."""
+        self.browser.find_by_xpath(f'//*[@id="object_list_form"]//tbody/tr[{row}]/td[{column}]/a').click()
+
     @property
     def objects_list_visible_items(self):
         """
@@ -108,6 +112,22 @@ class ObjectsListMixin:
         self.click_button('#default-filter button[type="submit"]')
 
 
+class ObjectDetailsMixin:
+    def assertPanelValue(self, panel_label, field_label, expected_value, exact_match=False):
+        """
+        Find the proper panel and asserts if given value match rendered field value.
+        By default, it's not using the exact match, because on the UI we're often adding
+        additional tags, relationships or units.
+        """
+        panel_xpath = f'//*[@id="main"]//div[@class="panel-heading"][contains(normalize-space(), "{panel_label}")]/following-sibling::table'
+        value = self.browser.find_by_xpath(f'{panel_xpath}//td[text()="{field_label}"]/following-sibling::td[1]').text
+
+        if exact_match:
+            self.assertEqual(value, str(expected_value))
+        else:
+            self.assertIn(str(expected_value), value)
+
+
 class BulkOperationsMixin:
     def confirm_bulk_delete_operation(self):
         """
@@ -196,6 +216,7 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
 
     host = "0.0.0.0"  # noqa: S104  # hardcoded-bind-all-interfaces -- false positive
     selenium_host = SELENIUM_HOST  # Docker: `nautobot`; else `host.docker.internal`
+    logged_in = False
 
     @classmethod
     def setUpClass(cls):
@@ -219,6 +240,10 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
     def live_server_url(cls):  # pylint: disable=no-self-argument
         return f"http://{cls.selenium_host}:{cls.server_thread.port}"
 
+    def tearDown(self):
+        if self.logged_in:
+            self.logout()
+
     @classmethod
     def tearDownClass(cls):
         """Close down the browser after tests are ran."""
@@ -291,19 +316,27 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
         self.browser.is_element_not_present_by_css(".loading-results", wait_time=5)
         return search_box
 
+    def _select_select2_result(self):
+        found_results = self.browser.find_by_css(".select2-results li.select2-results__option")
+        # click the first found item if it's not `None`: special value to nullify field
+        if found_results.first.text != "None":
+            found_results.first.click()
+        else:
+            found_results[1].click()
+
     def fill_select2_field(self, field_name, value):
         """
         Helper function to fill a Select2 single selection field on add/edit forms.
         """
-        search_box = self._fill_select2_field(field_name, value)
-        search_box.first.type(Keys.ENTER)
+        self._fill_select2_field(field_name, value)
+        self._select_select2_result()
 
     def fill_filters_select2_field(self, field_name, value):
         """
         Helper function to fill a Select2 single selection field on filters modals.
         """
         self._fill_select2_field(field_name, value, search_box_class="select2-search select2-search--inline")
-        self.browser.find_by_xpath(f"//li[contains(@class, 'select2-results__option') and text()='{value}']").click()
+        self._select_select2_result()
 
     def fill_select2_multiselect_field(self, field_name, value):
         """
@@ -327,6 +360,7 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
         self.user.is_superuser = True
         self.user.save()
         self.login(self.user.username, self.password)
+        self.logged_in = True
 
 
 class BulkOperationsTestCases:
@@ -367,10 +401,6 @@ class BulkOperationsTestCases:
             self.login_as_superuser()
             self.go_to_model_list_page()
 
-        def tearDown(self):
-            self.logout()
-            super().tearDown()
-
         def go_to_model_list_page(self):
             self.click_navbar_entry(*self.model_menu_path)
             self.assertEqual(self.browser.url, self.live_server_url + reverse(f"{self.model_base_viewname}_list"))

nautobot/core/tests/test_api.py

@@ -609,7 +609,7 @@ class WritableNestedSerializerTest(testing.APITestCase):
             dcim_models.LocationType.objects.get(name="Building"),
         ]
         for location_type in self.locations_types:
-            location_type.content_types.set([vlan_group_ct, vlan_ct])
+            location_type.content_types.add(vlan_group_ct, vlan_ct)
 
         self.statuses = extras_models.Status.objects.get_for_model(dcim_models.Location)
         self.location1 = dcim_models.Location.objects.create(

nautobot/core/tests/test_commands.py

@@ -0,0 +1,31 @@
+from io import StringIO
+
+from django.core.management import call_command
+import yaml
+
+from nautobot.core.testing import TestCase
+
+
+class ManagementCommandTestCase(TestCase):
+    """Test case for core management commands."""
+
+    def setUp(self):
+        """Initialize user and client."""
+        super().setUpNautobot()
+        self.user.is_superuser = True
+        self.user.is_staff = True
+        self.user.save()
+        self.client.force_login(self.user)
+
+    def test_generate_performance_test_endpoints(self):
+        """Test the generate_performance_test_endpoints management command."""
+        out = StringIO()
+        call_command("generate_performance_test_endpoints", stdout=out)
+        endpoints_dict = yaml.safe_load(out.getvalue())["endpoints"]
+        # status_code_to_endpoints = collections.defaultdict(list)
+        for view_name, value in endpoints_dict.items():
+            for endpoint in value:
+                response = self.client.get(endpoint, follow=True)
+                self.assertHttpStatus(
+                    response, 200, f"{view_name}: {endpoint} returns status Code {response.status_code} instead of 200"
+                )

nautobot/core/tests/test_graphql.py

@@ -8,7 +8,7 @@ from django.apps import apps
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import Group
 from django.contrib.contenttypes.models import ContentType
-from django.db.models import Q
+from django.db.models import Count, Q
 from django.test import override_settings, TestCase
 from django.test.client import RequestFactory
 from django.urls import reverse
@@ -919,8 +919,8 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
                 priority=789,
             ),
         )
-        prefixes = Prefix.objects.all()[:2]
-        cls.namespace = prefixes[0].namespace
+        cls.namespace = Namespace.objects.annotate(prefix_count=Count("prefixes")).filter(prefix_count__gt=2).first()
+        prefixes = Prefix.objects.filter(namespace=cls.namespace)
         vrfs = (
             VRF.objects.create(name="VRF 1", rd="65000:100", namespace=cls.namespace),
             VRF.objects.create(name="VRF 2", rd="65000:200", namespace=cls.namespace),

nautobot/core/tests/test_jobs.py

@@ -1,3 +1,4 @@
+import codecs
 from datetime import timedelta
 import json
 from pathlib import Path
@@ -72,7 +73,9 @@ class ExportObjectListTest(TransactionTestCase):
         self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
         self.assertTrue(job_result.files.exists())
         self.assertEqual(Path(job_result.files.first().file.name).name, "nautobot_statuses.csv")
-        csv_data = job_result.files.first().file.read().decode("utf-8")
+        csv_bytes = job_result.files.first().file.read()
+        self.assertTrue(csv_bytes.startswith(codecs.BOM_UTF8), csv_bytes)
+        csv_data = csv_bytes.decode("utf-8")
         self.assertIn(str(instance1.pk), csv_data)
         self.assertNotIn(str(instance2.pk), csv_data)
 

nautobot/core/tests/test_utils.py

@@ -273,10 +273,25 @@ class GetFooForModelTest(TestCase):
         """
         Test that `get_model_for_view_name` returns the appropriate Model, if the colon separated view name provided.
         """
-        with self.subTest("Test core view."):
+        with self.subTest("Test core UI view."):
             self.assertEqual(lookup.get_model_for_view_name("dcim:device_list"), dcim_models.Device)
-        with self.subTest("Test app view."):
+            self.assertEqual(lookup.get_model_for_view_name("dcim:device"), dcim_models.Device)
+        with self.subTest("Test app UI view."):
             self.assertEqual(lookup.get_model_for_view_name("plugins:example_app:examplemodel_list"), ExampleModel)
+            self.assertEqual(lookup.get_model_for_view_name("plugins:example_app:examplemodel"), ExampleModel)
+        with self.subTest("Test core API view."):
+            self.assertEqual(lookup.get_model_for_view_name("dcim-api:device-list"), dcim_models.Device)
+            self.assertEqual(lookup.get_model_for_view_name("dcim-api:device-detail"), dcim_models.Device)
+        with self.subTest("Test app API view."):
+            self.assertEqual(
+                lookup.get_model_for_view_name("plugins-api:example_app-api:examplemodel-detail"), ExampleModel
+            )
+            self.assertEqual(
+                lookup.get_model_for_view_name("plugins-api:example_app-api:examplemodel-list"), ExampleModel
+            )
+        with self.subTest("Test unconventional model views."):
+            self.assertEqual(lookup.get_model_for_view_name("extras-api:contenttype-detail"), ContentType)
+            self.assertEqual(lookup.get_model_for_view_name("users-api:group-detail"), Group)
         with self.subTest("Test unexpected view."):
             with self.assertRaises(ValueError) as err:
                 lookup.get_model_for_view_name("unknown:plugins:example_app:examplemodel_list")

nautobot/core/ui/object_detail.py

@@ -1372,7 +1372,7 @@ class StatsPanel(Panel):
                 value = [related_object_list_url, related_object_count, related_object_title]
                 stats[related_object_model_class] = value
                 related_object_model_filterset = get_filterset_for_model(related_object_model_class)
-                if self.filter_name not in related_object_model_filterset.declared_filters:
+                if self.filter_name not in related_object_model_filterset.get_filters():
                     raise FieldDoesNotExist(
                         f"{self.filter_name} is not a valid filter field for {related_object_model_class_meta.verbose_name}"
                     )