nautobot 3.0.0a2__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

nautobot/core/tests/test_jobs.py

@@ -16,12 +16,13 @@ from nautobot.core.jobs import ExportObjectList
 from nautobot.core.jobs.cleanup import CleanupTypes
 from nautobot.core.testing import create_job_result_and_run_job, TransactionTestCase
 from nautobot.core.testing.context import load_event_broker_override_settings
-from nautobot.dcim.models import Device, DeviceType, Location, LocationType, Manufacturer
-from nautobot.extras.choices import JobResultStatusChoices, LogLevelChoices
+from nautobot.dcim.models import Device, DeviceType, FrontPortTemplate, Location, LocationType, Manufacturer
+from nautobot.extras.choices import DynamicGroupTypeChoices, JobResultStatusChoices, LogLevelChoices
 from nautobot.extras.factory import JobResultFactory, ObjectChangeFactory
 from nautobot.extras.models import (
     Contact,
     ContactAssociation,
+    DynamicGroup,
     ExportTemplate,
     FileProxy,
     JobLogEntry,
@@ -34,7 +35,7 @@ from nautobot.extras.models import (
 )
 from nautobot.extras.models.metadata import ObjectMetadata
 from nautobot.ipam.models import IPAddress, Namespace, Prefix
-from nautobot.users.models import ObjectPermission
+from nautobot.users.models import ObjectPermission, User
 
 
 class ExportObjectListTest(TransactionTestCase):
@@ -1248,3 +1249,143 @@ class BulkDeleteTestCase(TransactionTestCase):
             saved_view_id=None,
         )
         self._common_no_error_test_assertion(Role, job_result, name__istartswith="Example Status")
+
+
+class RefreshDynamicGroupCacheJobButtonReceiverTestCase(TransactionTestCase):
+    job_module = "nautobot.core.jobs.groups"
+    job_name = "RefreshDynamicGroupCacheJobButtonReceiver"
+
+    def test_successful_cache_refresh(self):
+        LocationType.objects.create(name="DG Test LT 1")
+        LocationType.objects.create(name="DG Test LT 2")
+        LocationType.objects.create(name="DG Test LT 3")
+        dg = DynamicGroup(
+            name="Location Types",
+            content_type=ContentType.objects.get_for_model(LocationType),
+            group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_FILTER,
+            filter={"name__isw": ["DG Test"]},
+        )
+        dg.clean()
+        dg.save(update_cached_members=False)
+        self.assertEqual(0, dg.count)
+
+        job_result = create_job_result_and_run_job(
+            self.job_module,
+            self.job_name,
+            object_model_name="extras.dynamicgroup",
+            object_pk=dg.pk,
+        )
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertEqual(3, dg.count)
+
+        dg.filter = {"name__iew": ["DG Test"]}
+        dg.clean()
+        dg.save(update_cached_members=False)
+        self.assertEqual(3, dg.count)
+        job_result = create_job_result_and_run_job(
+            self.job_module,
+            self.job_name,
+            object_model_name="extras.dynamicgroup",
+            object_pk=dg.pk,
+        )
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertEqual(0, dg.count)
+
+    def test_failure_on_non_dg(self):
+        job_result = create_job_result_and_run_job(
+            self.job_module,
+            self.job_name,
+            object_model_name="extras.status",
+            object_pk=Status.objects.first().pk,
+        )
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
+        log_fail = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_FAILURE)
+        self.assertEqual(log_fail.message, "This job button should only be used with Dynamic Group records.")
+
+    def test_failure_on_static_dg(self):
+        dg = DynamicGroup.objects.create(
+            name="Location Types",
+            content_type=ContentType.objects.get_for_model(LocationType),
+            group_type=DynamicGroupTypeChoices.TYPE_STATIC,
+        )
+        job_result = create_job_result_and_run_job(
+            self.job_module,
+            self.job_name,
+            object_model_name="extras.dynamicgroup",
+            object_pk=dg.pk,
+        )
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
+        log_fail = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_FAILURE)
+        self.assertEqual(
+            log_fail.message,
+            "The members of this Dynamic Group are statically defined and do not need to be recalculated.",
+        )
+
+
+class ValidateModelDataTestCase(TransactionTestCase):
+    job_module = "nautobot.core.jobs"
+    job_name = "ValidateModelData"
+
+    def test_successful_validation(self):
+        job_result = create_job_result_and_run_job(
+            self.job_module,
+            self.job_name,
+            content_types=[ContentType.objects.get_for_model(Status).pk],
+            verbose=True,
+        )
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_SUCCESS)
+
+    def test_failure_on_invalid_dg(self):
+        dg = DynamicGroup(
+            name="Legacy rear_port_template filter",
+            filter={"rear_port_template": "74aac78c-fabb-468c-a036-26c46c56f27a"},
+            content_type=ContentType.objects.get_for_model(FrontPortTemplate),
+        )
+        dg.save(update_cached_members=False)
+        job_result = create_job_result_and_run_job(
+            self.job_module,
+            self.job_name,
+            content_types=[ContentType.objects.get_for_model(DynamicGroup).pk],
+            verbose=False,
+        )
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
+        log_fail = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_FAILURE)
+        self.assertIn("Enter a list of values", log_fail.message)
+
+    def test_warning_without_permission(self):
+        job_result = create_job_result_and_run_job(
+            self.job_module,
+            self.job_name,
+            username=self.user.username,  # otherwise run_job_for_testing defaults to a superuser account
+            content_types=[ContentType.objects.get_for_model(Status).pk],
+            verbose=True,
+        )
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_SUCCESS)
+        log_warn = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING)
+        self.assertEqual("No statuses found", log_warn.message)
+        self.assertIsNone(
+            JobLogEntry.objects.filter(
+                job_result=job_result, log_level=LogLevelChoices.LOG_SUCCESS, message="Validated successfully"
+            ).first()
+        )
+
+    def test_no_restrict_superuser(self):
+        job_result = create_job_result_and_run_job(
+            self.job_module,
+            self.job_name,
+            content_types=[ContentType.objects.get_for_model(User).pk],
+            verbose=True,
+        )
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_SUCCESS)
+
+    def test_no_restrict_non_superuser(self):
+        job_result = create_job_result_and_run_job(
+            self.job_module,
+            self.job_name,
+            username=self.user.username,  # otherwise run_job_for_testing defaults to a superuser account
+            content_types=[ContentType.objects.get_for_model(User).pk],
+            verbose=True,
+        )
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
+        log_fail = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_FAILURE)
+        self.assertIn("Unable to apply access permissions to users.user", log_fail.message)

nautobot/core/tests/test_nautobot_server.py

@@ -13,6 +13,7 @@ from unittest import mock, TestCase
 
 from django import __version__ as django_version
 from django.conf import settings
+from django.test import tag
 
 from nautobot import __version__ as nautobot_version
 
@@ -101,6 +102,7 @@ class NautobotServerTestCase(TestCase):
 
         self.assertNotEqual(secret_key_1, secret_key_2)
 
+    @tag("example_app")
     def test_settings_processing(self):
         result = subprocess.run(
             ["nautobot-server", "--config", settings.SETTINGS_PATH, "print_settings"],

nautobot/core/tests/test_navigations.py

@@ -1,9 +1,15 @@
+import os
+
+from django.apps import apps
 from django.test import tag, TestCase
 from django.urls import resolve
 
+from nautobot.core.apps import NavMenuTab
 from nautobot.core.choices import ButtonActionColorChoices, ButtonActionIconChoices
 from nautobot.core.testing.utils import get_expected_menu_item_name
+from nautobot.core.ui.choices import NavigationIconChoices, NavigationWeightChoices
 from nautobot.core.utils.lookup import get_route_for_model
+from nautobot.core.utils.module_loading import import_string_optional
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.extras.registry import registry
 
@@ -45,7 +51,8 @@ class NavMenuTestCase(TestCase):
                         except AttributeError:
                             # Not a model view?
                             self.assertIn(
-                                item_details["name"], {"Apps Marketplace", "Installed Apps", "Interface Connections"}
+                                item_details["name"],
+                                {"Apps Marketplace", "Installed Apps", "Interface Connections", "Device Constraints"},
                             )
 
                     for button, button_details in item_details["buttons"].items():
@@ -81,3 +88,71 @@ class NavMenuTestCase(TestCase):
                 else:
                     expected_perms[tab_name] |= group_perms
             self.assertEqual(expected_perms[tab_name], tab_details["permissions"])
+
+    def test_nav_menu_tabs_have_icon_and_weight(self):
+        """Ensure each NavMenuTab in every navigation.py has an icon and weight set, and any duplicates by name match."""
+        tabs_by_name = {}
+        for app in apps.get_app_configs():
+            if not app.name.startswith("nautobot."):
+                continue
+            nav_path = f"{app.name}.navigation.menu_items"
+            menu_items = import_string_optional(nav_path)
+            if menu_items is None:
+                continue
+            for tab in menu_items:
+                if not isinstance(tab, NavMenuTab):
+                    raise TypeError(f"Expected NavMenuTab instance in {nav_path}, got {type(tab)}")
+                tab_name = tab.name
+                icon = tab.icon
+                weight = tab.weight
+                with self.subTest(tab_name=tab_name, nav_path=nav_path):
+                    self.assertIsNotNone(tab_name, f"Tab in {nav_path} missing 'name'")
+                    self.assertIsNotNone(icon, f"Tab '{tab_name}' in {nav_path} missing 'icon'")
+                    self.assertIsNotNone(weight, f"Tab '{tab_name}' in {nav_path} missing 'weight'")
+                    if tab_name in tabs_by_name:
+                        prev_icon, prev_weight, prev_path = tabs_by_name[tab_name]
+                        self.assertEqual(
+                            icon,
+                            prev_icon,
+                            f"Tab '{tab_name}' has inconsistent icons: '{icon}' in {nav_path} vs '{prev_icon}' in {prev_path}",
+                        )
+                        self.assertEqual(
+                            weight,
+                            prev_weight,
+                            f"Tab '{tab_name}' has inconsistent weights: '{weight}' in {nav_path} vs '{prev_weight}' in {prev_path}",
+                        )
+                    else:
+                        tabs_by_name[tab_name] = (icon, weight, nav_path)
+
+    def test_icon_and_weight_class_attributes_match(self):
+        """
+        Ensure every class attribute in NavigationIconChoices is also in NavigationWeightChoices and vice versa.
+        If not, print the missing/extra attributes for easier debugging.
+        """
+        icon_attrs = {attr for attr in dir(NavigationIconChoices) if attr.isupper()}
+        weight_attrs = {attr for attr in dir(NavigationWeightChoices) if attr.isupper()}
+
+        only_in_icons = sorted(icon_attrs - weight_attrs)
+        only_in_weights = sorted(weight_attrs - icon_attrs)
+
+        if only_in_icons or only_in_weights:
+            msg = []
+            if only_in_icons:
+                msg.append(f"Class attributes only in NavigationIconChoices: {only_in_icons}")
+            if only_in_weights:
+                msg.append(f"Class attributes only in NavigationWeightChoices: {only_in_weights}")
+            self.fail("\n".join(msg))
+
+    def test_navigation_icons_have_svg(self):
+        """Ensure every NavigationIconChoices icon has a corresponding SVG file."""
+        missing = []
+        svg_dir = os.path.abspath(
+            os.path.join(os.path.dirname(__file__), "..", "..", "project-static", "nautobot-icons")
+        )
+        icon_attrs = [attr for attr in dir(NavigationIconChoices) if attr.isupper() and not attr == "CHOICES"]
+        for icon_attr in icon_attrs:
+            icon_name = getattr(NavigationIconChoices, icon_attr)
+            svg_path = os.path.join(svg_dir, f"{icon_name}.svg")
+            if not os.path.isfile(svg_path):
+                missing.append(svg_path)
+        self.assertFalse(missing, f"Missing SVG files for NavigationIconChoices: {missing}")

nautobot/core/tests/test_patch_social_django.py

@@ -0,0 +1,42 @@
+"""
+Test suite for social_django storage patch.
+
+This tests that the monkeypatch correctly replaces the vulnerable create_user
+method with the secure version that raises AuthAlreadyAssociated instead of
+silently returning an existing user.
+
+Please see nautobot/core/utils/patch_social_django.py for details on the patch.
+"""
+
+from unittest.mock import MagicMock, patch
+
+from nautobot.core.testing import TestCase
+
+
+class PatchSocialDjangoTestCase(TestCase):
+    def test_django_storage_has_patch_at_import_time(self):
+        """
+        Test that importing DjangoStorage gives us the patched version.
+
+        This verifies that the patch applied in CoreConfig.ready() persists
+        and affects all imports of DjangoStorage throughout the application.
+        """
+        from django.db.utils import IntegrityError
+        from social_core.exceptions import AuthAlreadyAssociated
+        from social_django.models import DjangoStorage
+
+        # Mock user model to trigger IntegrityError
+        mock_user_model = MagicMock()
+        mock_manager = MagicMock()
+        mock_manager.create_user.side_effect = IntegrityError("duplicate key")
+        mock_user_model._default_manager = mock_manager
+
+        # Patch username_field and user_model methods to return our mock user model
+        with patch.object(DjangoStorage.user, "username_field", return_value="username"):
+            with patch.object(DjangoStorage.user, "user_model", return_value=mock_user_model):
+                # Should raise AuthAlreadyAssociated (patched behavior)
+                with self.assertRaises(AuthAlreadyAssociated):
+                    DjangoStorage.user.create_user(username="test", email="test@example.com")
+
+                # Verify vulnerable get() not called
+                mock_manager.get.assert_not_called()

nautobot/core/tests/test_renderers.py

@@ -0,0 +1,59 @@
+from unittest.mock import patch
+
+from django.test import override_settings, RequestFactory
+from django.urls import reverse
+from rest_framework.response import Response
+
+from nautobot.cloud.views import CloudResourceTypeUIViewSet
+from nautobot.core.testing import TestCase
+from nautobot.core.ui.titles import Titles
+from nautobot.core.views.renderers import NautobotHTMLRenderer
+
+
+class ObjectListViewTitlesTest(TestCase):
+    """
+    Test suite for verifying that Titles are correctly set in ObjectListView rendering.
+    """
+
+    user_permissions = ["cloud.view_cloudresourcetype"]
+
+    def setUp(self):
+        super().setUp()
+        self.factory = RequestFactory()
+
+    @override_settings(ALLOWED_HOSTS=["*"], PAGINATE_COUNT=5, MAX_PAGE_SIZE=10)
+    def test_uiviewset_list_view_title(self):
+        """
+        Test that the list view title is correctly set from the Titles configuration.
+        """
+
+        path = reverse("cloud:cloudresourcetype_list")
+        request = self.factory.get(path)
+        request.user = self.user
+        viewset_class = CloudResourceTypeUIViewSet
+        with patch.object(CloudResourceTypeUIViewSet, "view_titles", Titles(titles={"list": "Burritos"})):
+            view = viewset_class()
+            view.action_map = {"get": "list"}
+
+            request = view.initialize_request(request)
+
+            view.setup(request)
+            view.initial(request)
+
+            renderer = NautobotHTMLRenderer()
+            context = renderer.get_context(
+                data={},
+                accepted_media_type="text/html",
+                renderer_context={"view": view, "request": request, "response": Response({})},
+            )
+
+            # Verify that the title is set in the context
+            self.assertIn("view_titles", context)
+            self.assertNotIn(
+                "title", context
+            )  # title is used within the render path but should not be directly in context
+            self.assertEqual(context["view_titles"], viewset_class.view_titles)
+
+            # Finally, render the view and verify the title appears in the response
+            response = self.client.get(path)
+            self.assertContains(response, "Burritos")

nautobot/core/tests/test_settings_schema.py

@@ -132,6 +132,7 @@ class SettingsJSONSchemaTestCase(TestCase):
             "CSRF_FAILURE_VIEW",
             "DATA_UPLOAD_MAX_NUMBER_FIELDS",
             "DEFAULT_AUTO_FIELD",
+            "DJANGO_TABLES2_TEMPLATE",
             "DRF_REACT_TEMPLATE_TYPE_MAP",
             "EXEMPT_EXCLUDE_MODELS",
             "FILTERS_NULL_CHOICE_LABEL",

nautobot/core/tests/test_tables.py

@@ -1,4 +1,4 @@
-from django.test import TestCase
+from django.test import tag, TestCase
 
 from nautobot.circuits.models import Circuit
 from nautobot.circuits.tables import CircuitTable
@@ -32,6 +32,7 @@ class TableTestCase(TestCase):
             )
             self.assertEqual(list(table_queryset_data), list(sorted_queryset))
 
+    @tag("example_app")
     def test_tree_model_table_orderable(self):
         """Assert TreeNode model table are orderable."""
         location_type = LocationType.objects.get(name="Campus")
@@ -107,6 +108,7 @@ class TableTestCase(TestCase):
         )
         self.assertEqual(list(table_queryset_data), list(sorted_queryset))
 
+    @tag("example_app")
     def test_base_table_apis(self):
         """
         Test BaseTable APIs, specifically visible_columns and configurable_columns.

nautobot/core/tests/test_templatetags_helpers.py

@@ -1,14 +1,16 @@
+from unittest import mock
+
 from constance.test import override_config
 from django.conf import settings
+from django.contrib.staticfiles.testing import StaticLiveServerTestCase
 from django.templatetags.static import static
-from django.test import override_settings, TestCase
+from django.test import override_settings, tag
 
 from nautobot.core.templatetags import helpers
+from nautobot.core.testing import TestCase
 from nautobot.dcim import models
 from nautobot.ipam.models import VLAN
 
-from example_app.models import AnotherExampleModel, ExampleModel
-
 
 class NautobotTemplatetagsHelperTest(TestCase):
     def test_hyperlinked_object(self):
@@ -61,6 +63,9 @@ class NautobotTemplatetagsHelperTest(TestCase):
         self.assertEqual(helpers.pre_tag(None), '<span class="text-secondary">&mdash;</span>')
         self.assertEqual(helpers.pre_tag([]), "<pre>[]</pre>")
         self.assertEqual(helpers.pre_tag("something"), "<pre>something</pre>")
+        self.assertEqual(helpers.pre_tag("", format_empty_value=False), '<span class="text-secondary">&mdash;</span>')
+        self.assertEqual(helpers.pre_tag([], format_empty_value=False), '<span class="text-secondary">&mdash;</span>')
+        self.assertEqual(helpers.pre_tag("something", format_empty_value=False), "<pre>something</pre>")
 
     def test_add_html_id(self):
         # Case where what we have isn't actually a HTML element but just a bare string
@@ -132,6 +137,7 @@ class NautobotTemplatetagsHelperTest(TestCase):
         )
         self.assertEqual("utf8:\n- 😀😀\n- 😀\n", helpers.render_yaml({"utf8": ["😀😀", "😀"]}, False))
 
+    @tag("example_app")
     def test_meta(self):
         location = models.Location.objects.first()
 
@@ -139,31 +145,42 @@ class NautobotTemplatetagsHelperTest(TestCase):
         self.assertEqual(helpers.meta(models.Location, "app_label"), "dcim")
         self.assertEqual(helpers.meta(location, "not_present"), "")
 
+        from example_app.models import ExampleModel
+
         self.assertEqual(helpers.meta(ExampleModel, "app_label"), "example_app")
 
+    @tag("example_app")
     def test_viewname(self):
         location = models.Location.objects.first()
 
         self.assertEqual(helpers.viewname(location, "edit"), "dcim:location_edit")
         self.assertEqual(helpers.viewname(models.Location, "test"), "dcim:location_test")
 
+        from example_app.models import ExampleModel
+
         self.assertEqual(helpers.viewname(ExampleModel, "edit"), "plugins:example_app:examplemodel_edit")
 
+    @tag("example_app")
     def test_validated_viewname(self):
         location = models.Location.objects.first()
 
         self.assertEqual(helpers.validated_viewname(location, "list"), "dcim:location_list")
         self.assertIsNone(helpers.validated_viewname(models.Location, "notvalid"))
 
+        from example_app.models import ExampleModel
+
         self.assertEqual(helpers.validated_viewname(ExampleModel, "list"), "plugins:example_app:examplemodel_list")
         self.assertIsNone(helpers.validated_viewname(ExampleModel, "notvalid"))
 
+    @tag("example_app")
     def test_validated_api_viewname(self):
         location = models.Location.objects.first()
 
         self.assertEqual(helpers.validated_api_viewname(location, "list"), "dcim-api:location-list")
         self.assertIsNone(helpers.validated_api_viewname(models.Location, "notvalid"))
 
+        from example_app.models import ExampleModel
+
         self.assertEqual(
             helpers.validated_api_viewname(ExampleModel, "list"), "plugins-api:example_app-api:examplemodel-list"
         )
@@ -180,7 +197,13 @@ class NautobotTemplatetagsHelperTest(TestCase):
     def test_humanize_speed(self):
         self.assertEqual(helpers.humanize_speed(1544), "1.544 Mbps")
         self.assertEqual(helpers.humanize_speed(100000), "100 Mbps")
+        self.assertEqual(helpers.humanize_speed(2500000), "2.5 Gbps")
         self.assertEqual(helpers.humanize_speed(10000000), "10 Gbps")
+        self.assertEqual(helpers.humanize_speed(100000000), "100 Gbps")
+        self.assertEqual(helpers.humanize_speed(1000000000), "1 Tbps")
+        self.assertEqual(helpers.humanize_speed(1600000000), "1.6 Tbps")
+        self.assertEqual(helpers.humanize_speed(10000000000), "10 Tbps")
+        self.assertEqual(helpers.humanize_speed(100000000000), "100 Tbps")
 
     def test_tzoffset(self):
         self.assertTrue(callable(helpers.tzoffset))
@@ -201,16 +224,6 @@ class NautobotTemplatetagsHelperTest(TestCase):
         self.assertEqual(helpers.percentage(2, 10), 20)
         self.assertEqual(helpers.percentage(10, 3), 333)
 
-    def test_get_docs_url(self):
-        self.assertTrue(callable(helpers.get_docs_url))
-        location = models.Location.objects.first()
-        self.assertEqual(helpers.get_docs_url(location), static("docs/user-guide/core-data-model/dcim/location.html"))
-        example_model = ExampleModel.objects.create(name="test", number=1)
-        self.assertEqual(helpers.get_docs_url(example_model), static("example_app/docs/models/examplemodel.html"))
-        # AnotherExampleModel does not have documentation.
-        another_model = AnotherExampleModel.objects.create(name="test", number=1)
-        self.assertIsNone(helpers.get_docs_url(another_model))
-
     def test_has_perms(self):
         self.assertTrue(callable(helpers.has_perms))
         # TODO add unit tests for has_perms
@@ -265,6 +278,7 @@ class NautobotTemplatetagsHelperTest(TestCase):
         # Assert when obj is None
         self.assertEqual(helpers.hyperlinked_object_with_color(obj=None), '<span class="text-secondary">&mdash;</span>')
 
+    @tag("example_app")
     @override_settings(BANNER_TOP="¡Hola, mundo!")
     @override_config(example_app__SAMPLE_VARIABLE="Testing")
     def test_settings_or_config(self):
@@ -338,3 +352,38 @@ class NautobotTemplatetagsHelperTest(TestCase):
             "-85 dBm",
         )
         self.assertEqual(helpers.dbm(None), helpers.placeholder(None))
+
+
+@tag("test")
+class NautobotStaticDocsTestCase(StaticLiveServerTestCase):
+    @tag("example_app")
+    def test_get_docs_url(self):
+        self.assertTrue(callable(helpers.get_docs_url))
+        location_type = models.LocationType.objects.create(name="Some Location Type")
+        self.assertEqual(
+            helpers.get_docs_url(location_type), static("docs/user-guide/core-data-model/dcim/locationtype.html")
+        )
+
+        from example_app.models import AnotherExampleModel, ExampleModel
+
+        example_model = ExampleModel.objects.create(name="test", number=1)
+        self.assertEqual(helpers.get_docs_url(example_model), "/docs/example-app/models/examplemodel.html")
+        # AnotherExampleModel does not have documentation.
+        another_model = AnotherExampleModel.objects.create(name="test", number=1)
+        self.assertIsNone(helpers.get_docs_url(another_model))
+
+    @tag("example_app")
+    @mock.patch("nautobot.core.templatetags.helpers.find", return_value=False)
+    @mock.patch("nautobot.core.templatetags.helpers.resources.files", side_effect=ModuleNotFoundError)
+    def test_get_docs_url_module_not_found_and_no_static_file(self, mock_files, mock_find):
+        # Force `resources.files()` to raise ModuleNotFoundError to simulate a plugin
+        # that is listed in settings.PLUGINS but doesn't actually exist on disk.
+        # This ensures the `except ModuleNotFoundError` branch is covered.
+        from example_app.models import ExampleModel
+
+        example_model = ExampleModel.objects.create(name="test", number=1)
+        result = helpers.get_docs_url(example_model)
+        self.assertIsNone(result)
+
+        mock_files.assert_called_once()
+        mock_find.assert_called_once()

nautobot/core/tests/test_templatetags_ui_framework.py

@@ -65,7 +65,7 @@ class NautobotTemplatetagsUIComponentsTest(TestCase):
             {
                 "list_url": "home",
                 "title": "New Home",
-                "view_action": "list",
+                "detail": True,
                 "breadcrumbs": Breadcrumbs(),
             }
         )
@@ -98,7 +98,7 @@ class NautobotTemplatetagsUIComponentsTest(TestCase):
             {
                 "list_url": "home",
                 "title": "New Home",
-                "view_action": "list",
+                "detail": True,
                 "breadcrumbs": Breadcrumbs(),
             }
         )
@@ -126,7 +126,7 @@ class NautobotTemplatetagsUIComponentsTest(TestCase):
             {
                 "list_url": "home",
                 "title": "New Home",
-                "view_action": "list",
+                "detail": True,
                 "breadcrumbs": Breadcrumbs(),
             }
         )
@@ -152,7 +152,7 @@ class NautobotTemplatetagsUIComponentsTest(TestCase):
             {
                 "list_url": "home",
                 "title": "New Home",
-                "view_action": "list",
+                "detail": True,
                 "breadcrumbs": Breadcrumbs(),
             }
         )

nautobot/core/tests/test_titles.py

@@ -107,22 +107,6 @@ class TitlesTestCase(TestCase):
                 "context": {"view_action": "bulk_update", "objs_count": 10, "verbose_name_plural": "devices"},
                 "expected": "Editing 10 Devices",
             },
-            {
-                "name": "changelog_action",
-                "context": {
-                    "view_action": "changelog",
-                    "object": location_type,
-                },
-                "expected": "Test Location Type Title - Change Log",
-            },
-            {
-                "name": "notes_action",
-                "context": {
-                    "view_action": "notes",
-                    "object": location_type,
-                },
-                "expected": "Test Location Type Title - Notes",
-            },
             {
                 "name": "approve_action",
                 "context": {"view_action": "approve", "verbose_name": "device"},

nautobot/core/tests/test_tree_queries.py

@@ -13,8 +13,21 @@ class TestInvalidateMaxTreeDepthSignal(TestCase):
         # Ensure that the max_depth hasn't already been cached
         Location.objects.__dict__.pop("max_depth", None)
         location = Location.objects.first()
-        with self.assertNumQueries(1):
+
+        with CaptureQueriesContext(connection) as ctx:
             location.save()
+            captured_tree_cte_queries = [
+                query["sql"] for query in ctx.captured_queries if "WITH RECURSIVE" in query["sql"]
+            ]
+        allowed_number_of_tree_queries = 0  # We don't expect any tree queries to be run
+        _query_separator = "\n" + ("-" * 10) + "\n" + "NEXT QUERY" + "\n" + ("-" * 10)
+        self.assertEqual(
+            len(captured_tree_cte_queries),
+            allowed_number_of_tree_queries,
+            f"The CTE tree was calculated a different number of times ({len(captured_tree_cte_queries)})"
+            f" than allowed ({allowed_number_of_tree_queries})."
+            f" The following queries were used:\n{_query_separator.join(captured_tree_cte_queries)}",
+        )
 
 
 class QuerySetAncestorTests(TestCase):