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

nautobot/core/tests/test_forms.py

@@ -1,21 +1,26 @@
+import inspect
+import sys
 from unittest import mock
 
 from django import forms as django_forms
+from django.apps import apps as django_apps
 from django.contrib.contenttypes.models import ContentType
 from django.http import QueryDict
-from django.test import TestCase
+from django.test import tag
 from django.urls import reverse
+from django_filters.filterset import FilterSet
 from netaddr import IPNetwork
 
 from nautobot.core import filters, forms, testing
 from nautobot.core.utils import requests
+from nautobot.core.utils.filtering import get_filterset_parameter_form_field
 from nautobot.dcim import filters as dcim_filters, forms as dcim_forms, models as dcim_models
 from nautobot.dcim.tests import test_views
 from nautobot.extras import filters as extras_filters, models as extras_models
 from nautobot.ipam import forms as ipam_forms, models as ipam_models
 
 
-class ExpandIPAddress(TestCase):
+class ExpandIPAddress(testing.TestCase):
     """
     Validate the operation of expand_ipaddress_pattern().
     """
@@ -198,7 +203,7 @@ class ExpandIPAddress(TestCase):
             sorted(forms.expand_ipaddress_pattern("1.2.3.[4,,5]/32", 4))
 
 
-class ExpandAlphanumeric(TestCase):
+class ExpandAlphanumeric(testing.TestCase):
     """
     Validate the operation of expand_alphanumeric_pattern().
     """
@@ -332,7 +337,7 @@ class ExpandAlphanumeric(TestCase):
             sorted(forms.expand_alphanumeric_pattern("r[a,,b]a"))
 
 
-class AddFieldToFormClassTest(TestCase):
+class AddFieldToFormClassTest(testing.TestCase):
     def test_field_added(self):
         """
         Test adding of a new field to an existing form.
@@ -361,7 +366,7 @@ class AddFieldToFormClassTest(TestCase):
             )
 
 
-class DynamicModelChoiceFieldTest(TestCase):
+class DynamicModelChoiceFieldTest(testing.TestCase):
     """Tests for DynamicModelChoiceField."""
 
     def setUp(self):
@@ -397,7 +402,7 @@ class DynamicModelChoiceFieldTest(TestCase):
         self.assertEqual(self.field_with_to_field_name.prepare_value(address), address.address)
 
 
-class DynamicModelMultipleChoiceFieldTest(TestCase):
+class DynamicModelMultipleChoiceFieldTest(testing.TestCase):
     """Tests for DynamicModelMultipleChoiceField."""
 
     def setUp(self):
@@ -434,7 +439,7 @@ class DynamicModelMultipleChoiceFieldTest(TestCase):
         )
 
 
-class MultiValueCharFieldTest(TestCase):
+class MultiValueCharFieldTest(testing.TestCase):
     def setUp(self):
         self.filter = filters.MultiValueCharFilter()
         self.field = forms.MultiValueCharField()
@@ -467,7 +472,7 @@ class MultiValueCharFieldTest(TestCase):
         )
 
 
-class NumericArrayFieldTest(TestCase):
+class NumericArrayFieldTest(testing.TestCase):
     def setUp(self):
         super().setUp()
         # We need to use a field with required=False so we can test empty/None inputs
@@ -497,7 +502,7 @@ class NumericArrayFieldTest(TestCase):
                 self.field.clean(test)
 
 
-class AddressFieldMixinTest(TestCase):
+class AddressFieldMixinTest(testing.TestCase):
     """Test cases for the AddressFieldMixin."""
 
     def setUp(self):
@@ -527,7 +532,7 @@ class AddressFieldMixinTest(TestCase):
             mock_init.assert_called_with(initial=self.initial, instance=self.ip)
 
 
-class PrefixFieldMixinTest(TestCase):
+class PrefixFieldMixinTest(testing.TestCase):
     """Test cases for the PrefixFieldMixin."""
 
     def setUp(self):
@@ -576,7 +581,7 @@ class JSONFieldTest(testing.TestCase):
         self.assertEqual('"I am UTF-8! 😀"', forms.JSONField().prepare_value("I am UTF-8! 😀"))
 
 
-class MultiMatchModelMultipleChoiceFieldTest(TestCase):
+class MultiMatchModelMultipleChoiceFieldTest(testing.TestCase):
     def test_clean(self):
         field = forms.MultiMatchModelMultipleChoiceField(
             queryset=ipam_models.VLANGroup.objects.all(), to_field_name="name"
@@ -604,20 +609,57 @@ class MultiMatchModelMultipleChoiceFieldTest(TestCase):
                 field.clean(value)
 
 
-class WidgetsTest(TestCase):
+class WidgetsTest(testing.TestCase):
     def test_api_select_add_query_param_with_utf8(self):
         widget = forms.APISelect()
         widget.add_query_param("utf8", "I am UTF-8! 😀")
         self.assertEqual('["I am UTF-8! 😀"]', widget.attrs["data-query-param-utf8"])
 
 
-class DynamicFilterFormTest(TestCase):
+class DynamicFilterFormTest(testing.TestCase):
+    def test_get_filterset_parameter_form_field_all_filters(self):
+        """
+        Test every FilterSet to validate that Plural names are correctly mapped in get_filterset_parameter_form_field.
+        """
+        filterset_classes = set()
+        for app_config in django_apps.get_app_configs():
+            try:
+                filters_mod = sys.modules.get(f"{app_config.name}.filters")
+                if not filters_mod:
+                    continue
+                for _name, obj in inspect.getmembers(filters_mod):
+                    if (
+                        inspect.isclass(obj)  # Check if obj is a class
+                        and issubclass(obj, FilterSet)  # Check if obj is a subclass of FilterSet
+                        and obj is not FilterSet  # Exclude the base FilterSet class itself
+                        and getattr(getattr(obj, "_meta", None), "model", None)
+                        is not None  # Ensure the FilterSet has a model defined
+                    ):
+                        filterset_classes.add(obj)
+            except Exception as e:
+                # This test might start failing if an app's filters.py gets a design change.
+                self.fail(f"Error processing app '{app_config.name}': {e}")
+        for filterset_class in filterset_classes:
+            filterset = filterset_class()
+            model = filterset._meta.model
+            for filter_name in filterset.filters.keys():
+                try:
+                    field = get_filterset_parameter_form_field(model, filter_name, filterset=filterset)
+                    self.assertIsNotNone(field, "Field was unexpectedly None")
+                except KeyError as e:
+                    self.fail(
+                        f"A filter failed to operate due to mismatched plural name:"
+                        f" Check MODEL_VERBOSE_NAME_PLURAL_TO_FEATURE_NAME_MAPPING:"
+                        f" FilterClass: {filterset_class.__name__} name: {filter_name}: {e}"
+                    )
+
     # TODO(timizuo): investigate why test fails on CI
     # def test_dynamic_filter_form_with_missing_attr(self):
     #     with self.assertRaises(AttributeError) as err:
     #         DynamicFilterForm()
     #     self.assertEqual("'DynamicFilterForm' object requires `filterset_class` attribute", str(err.exception))
 
+    @tag("example_app")
     def test_dynamic_filter_form(self):
         form = forms.DynamicFilterForm(filterset=extras_filters.StatusFilterSet())
         location_form = forms.DynamicFilterForm(filterset=dcim_filters.LocationFilterSet())

nautobot/core/tests/test_jobs.py

@@ -17,11 +17,12 @@ 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.extras.choices import DynamicGroupTypeChoices, JobResultStatusChoices, LogLevelChoices
 from nautobot.extras.factory import JobResultFactory, ObjectChangeFactory
 from nautobot.extras.models import (
     Contact,
     ContactAssociation,
+    DynamicGroup,
     ExportTemplate,
     FileProxy,
     JobLogEntry,
@@ -1248,3 +1249,76 @@ class BulkDeleteTestCase(TransactionTestCase):
             saved_view_id=None,
         )
         self._common_no_error_test_assertion(Role, job_result, name__istartswith="Example Status")
+
+
+class RefreshDynamicGroupCacheJobButtonReceiverTestCase(TransactionTestCase):
+    def setUp(self):
+        super().setUp()
+        self.job_module = "nautobot.core.jobs.groups"
+        self.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.",
+        )

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_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):
@@ -132,6 +134,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 +142,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"
         )
@@ -201,16 +215,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 +269,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 +343,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_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):

nautobot/core/tests/test_ui.py

@@ -446,7 +446,7 @@ class ObjectDetailContentExtraTabsTest(TestCase):
         self.factory = RequestFactory()
         self.request = self.factory.get("/")
         self.request.user = self.user
-        self.default_tabs_id = ["main", "advanced", "contacts", "dynamic_groups", "object_metadata"]
+        self.default_tabs_id = ["main", "advanced", "contacts", "dynamic_groups", "object_metadata", "data_compliance"]
 
     def test_default_extra_tabs_exist(self):
         """