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

nautobot/core/tests/test_ui.py

@@ -32,7 +32,9 @@ from nautobot.core.ui.object_detail import (
     SectionChoices,
 )
 from nautobot.dcim.models import Device, DeviceRedundancyGroup, Location
+from nautobot.dcim.tables import DeviceModuleInterfaceTable
 from nautobot.dcim.tables.devices import DeviceTable
+from nautobot.dcim.views import DeviceUIViewSet
 from nautobot.ipam.models import Prefix
 
 
@@ -355,9 +357,80 @@ class EChartsBaseTests(TestCase):
         self.assertEqual(config["series"][0]["name"], "S1")
         self.assertEqual(config["series"][1]["name"], "S2")
 
-    def test_get_config_with_callable_data(self):
-        chart = EChartsBase(data=lambda: self.data_normalized)
-        config = chart.get_config()
+    def test_get_config_combined_charts_with_complex_data(self):
+        chart2 = EChartsBase(
+            chart_type=EChartsTypeChoices.LINE,
+            data={
+                "Compliant": {"aaa1": 5, "dns1": 12, "ntp1": 8},
+                "Non Compliant": {"aaa1": 10, "dns1": 20, "ntp1": 15},
+            },
+        )
+        chart1 = EChartsBase(
+            chart_type=EChartsTypeChoices.BAR,
+            data={
+                "Compliant": {"aaa": 5, "dns": 12, "ntp": 8},
+                "Non Compliant": {"aaa": 10, "dns": 20, "ntp": 15},
+            },
+            combined_with=chart2,
+        )
+        config = chart1.get_config()
+        self.assertEqual(len(config["series"]), 4)
+
+        self.assertEqual(config["series"][0], {"name": "Compliant", "type": "bar", "data": [5, 12, 8]})
+        self.assertEqual(config["series"][1], {"name": "Non Compliant", "type": "bar", "data": [10, 20, 15]})
+        self.assertEqual(
+            config["series"][2],
+            {"name": "Compliant", "type": "line", "data": [5, 12, 8], "smooth": False, "lineStyle": {}},
+        )
+        self.assertEqual(
+            config["series"][3],
+            {"name": "Non Compliant", "type": "line", "data": [10, 20, 15], "smooth": False, "lineStyle": {}},
+        )
+
+    def test_get_config_with_context_callable_and_combined_chart(self):
+        def main_data(ctx):
+            return {
+                "Compliant": {"aaa1": ctx.get("aaa1_count", 0), "dns1": 13, "ntp1": 8},
+                "Non Compliant": {"aaa1": 10, "dns1": 20, "ntp1": 15},
+            }
+
+        def combined_data(ctx):
+            return {
+                "Compliant": {"aaa": 5, "dns": ctx.get("dns_count", 0), "ntp1": 8},
+                "Non Compliant": {"aaa": 10, "dns": 20, "ntp1": 15},
+            }
+
+        ctx = Context({"aaa1_count": 5, "dns_count": 12})
+        combined_chart = EChartsBase(chart_type=EChartsTypeChoices.LINE, data=combined_data)
+        main_chart = EChartsBase(
+            chart_type=EChartsTypeChoices.BAR,
+            data=main_data,
+            combined_with=combined_chart,
+        )
+        config = main_chart.get_config(context=ctx)
+        self.assertEqual(len(config["series"]), 4)
+
+        self.assertEqual(config["series"][0]["data"][0], 5)  # aaa1_count
+        self.assertEqual(config["series"][2]["data"][1], 12)  # dns_count
+
+    def test_get_config_with_context_callable(self):
+        def dynamic_data(ctx):
+            return {"data": {"Devices": ctx.get("device_count", 0)}}
+
+        ctx = Context({"device_count": 42})
+        chart = EChartsBase(chart_type=EChartsTypeChoices.PIE, data=dynamic_data)
+        config = chart.get_config(context=ctx)
+        # check that after getting config data doesn't change it's still dynami_data function
+        self.assertEqual(chart.data, dynamic_data)
+        self.assertEqual(config["series"][0]["data"][0]["value"], 42)
+        ctx = Context({"device_count": 45})
+        config = chart.get_config(context=ctx)
+        self.assertEqual(config["series"][0]["data"][0]["value"], 45)
+
+    def test_get_config_with_context_ignored_when_data_is_not_callable(self):
+        ctx = Context({"some": "value"})
+        chart = EChartsBase(data=self.data_normalized)
+        config = chart.get_config(context=ctx)
         self.assertEqual(config["series"][0]["data"], [1, 2])
 
 
@@ -446,7 +519,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):
         """
@@ -492,6 +565,52 @@ class ObjectDetailContentExtraTabsTest(TestCase):
         self.default_tabs_id.append("services")
         self.assertListEqual(tab_ids, self.default_tabs_id)
 
+    def test_tab_id_url_as_action(self):
+        """
+        Test that when you create a panel with a tab_id that matches a viewset action,
+        the return_url is constructed correctly.
+        """
+        self.add_permissions("dcim.add_interface", "dcim.change_interface")
+        device_info = Device.objects.first()
+
+        panel = DeviceUIViewSet.DeviceInterfacesTablePanel(
+            weight=100,
+            section=SectionChoices.FULL_WIDTH,
+            table_title="Interfaces",
+            table_class=DeviceModuleInterfaceTable,
+            table_attribute="vc_interfaces",
+            related_field_name="device",
+            tab_id="interfaces",
+        )
+        context = {"request": self.request, "object": device_info}
+        panel_context = panel.get_extra_context(context)
+
+        return_url = f"/dcim/devices/{device_info.pk}/interfaces/"
+        self.assertTrue(panel_context["body_content_table_add_url"].endswith(return_url))
+
+    def test_tab_id_url_as_param(self):
+        """
+        Test that when you create a panel with a tab_id that does NOT matches a viewset action,
+        the return_url is constructed correctly.
+        """
+        self.add_permissions("dcim.add_interface", "dcim.change_interface")
+        device_info = Device.objects.first()
+
+        panel = DeviceUIViewSet.DeviceInterfacesTablePanel(
+            weight=100,
+            section=SectionChoices.FULL_WIDTH,
+            table_title="Interfaces",
+            table_class=DeviceModuleInterfaceTable,
+            table_attribute="vc_interfaces",
+            related_field_name="device",
+            tab_id="interfaces-not-exist",
+        )
+        context = {"request": self.request, "object": device_info}
+        panel_context = panel.get_extra_context(context)
+
+        return_url = f"&return_url=/dcim/devices/{device_info.pk}/?tab=interfaces-not-exist"
+        self.assertTrue(panel_context["body_content_table_add_url"].endswith(return_url))
+
     def test_extra_tab_panel_context(self):
         """
         Confirming that extra tab panels produce the correct context,

nautobot/core/tests/test_utils.py

@@ -9,7 +9,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.db.models import Q
 from django.http import QueryDict
-from django.test import override_settings
+from django.test import override_settings, tag
 
 from nautobot.circuits import models as circuits_models
 from nautobot.core import exceptions, forms, settings_funcs
@@ -20,9 +20,15 @@ from nautobot.core.testing import TestCase
 from nautobot.core.utils import data as data_utils, filtering, lookup, querysets, requests
 from nautobot.core.utils.cache import construct_cache_key
 from nautobot.core.utils.migrations import update_object_change_ct_for_replaced_models
-from nautobot.core.utils.module_loading import check_name_safe_to_import_privately
+from nautobot.core.utils.module_loading import check_name_safe_to_import_privately, import_string_optional
 from nautobot.data_validation import models as data_validation_models
-from nautobot.dcim import filters as dcim_filters, forms as dcim_forms, models as dcim_models, tables
+from nautobot.dcim import (
+    filters as dcim_filters,
+    forms as dcim_forms,
+    models as dcim_models,
+    tables,
+    views as dcim_views,
+)
 from nautobot.extras import models as extras_models, utils as extras_utils
 from nautobot.extras.choices import ObjectChangeActionChoices, RelationshipTypeChoices
 from nautobot.extras.filters import StatusFilterSet
@@ -30,8 +36,6 @@ from nautobot.extras.forms import StatusForm
 from nautobot.extras.models import ObjectChange
 from nautobot.ipam import models as ipam_models
 
-from example_app.models import ExampleModel
-
 
 class ConstructCacheKeyTest(TestCase):
     """
@@ -331,6 +335,26 @@ class GetFooForModelTest(TestCase):
         instance = extras_models.GraphQLQuery.objects.create(name="FizzBuzz", query="{devices { name }}")
         self.assertIsNone(lookup.get_user_from_instance(instance))
 
+    def test_get_breadcrumbs_for_model(self):
+        breadcrumbs = lookup.get_breadcrumbs_for_model(dcim_models.Device)
+        self.assertEqual(breadcrumbs.items, dcim_views.DeviceUIViewSet.get_breadcrumbs(dcim_models.Device).items)
+        breadcrumbs = lookup.get_breadcrumbs_for_model(dcim_models.Device, view_type="")
+        self.assertEqual(
+            breadcrumbs.items, dcim_views.DeviceUIViewSet.get_breadcrumbs(dcim_models.Device, view_type="").items
+        )
+
+    def test_get_detail_view_components_context_for_model(self):
+        context = lookup.get_detail_view_components_context_for_model(dcim_models.Device)
+        self.assertEqual(
+            context["breadcrumbs"].items, lookup.get_breadcrumbs_for_model(dcim_models.Device, view_type="").items
+        )
+        self.assertEqual(
+            context["object_detail_content"], lookup.get_object_detail_content_for_model(dcim_models.Device)
+        )
+        self.assertEqual(
+            context["view_titles"].titles, lookup.get_view_titles_for_model(dcim_models.Device, view_type="").titles
+        )
+
     def test_get_filterset_for_model(self):
         """
         Test that `get_filterset_for_model` returns the right FilterSet for various inputs.
@@ -353,6 +377,12 @@ class GetFooForModelTest(TestCase):
         self.assertEqual(lookup.get_form_for_model("dcim.location"), dcim_forms.LocationForm)
         self.assertEqual(lookup.get_form_for_model(dcim_models.Location), dcim_forms.LocationForm)
 
+    def test_get_object_detail_content_for_model(self):
+        self.assertEqual(
+            lookup.get_object_detail_content_for_model(dcim_models.Device),
+            dcim_views.DeviceUIViewSet.object_detail_content,
+        )
+
     def test_get_related_field_for_models(self):
         """
         Test that `get_related_field_for_models` returns the appropriate field for various inputs.
@@ -372,10 +402,13 @@ class GetFooForModelTest(TestCase):
             # both primary_ip4 and primary_ip6 are candidates
             lookup.get_related_field_for_models(dcim_models.Device, ipam_models.IPAddress)
 
+    @tag("example_app")
     def test_get_route_for_model(self):
         """
         Test that `get_route_for_model` returns the appropriate URL route name for various inputs.
         """
+        from example_app.models import ExampleModel
+
         # UI
         self.assertEqual(lookup.get_route_for_model("dcim.device", "list"), "dcim:device_list")
         self.assertEqual(lookup.get_route_for_model(dcim_models.Device, "list"), "dcim:device_list")
@@ -423,10 +456,13 @@ class GetFooForModelTest(TestCase):
         self.assertEqual(lookup.get_model_from_name("dcim.device"), dcim_models.Device)
         self.assertEqual(lookup.get_model_from_name("dcim.location"), dcim_models.Location)
 
+    @tag("example_app")
     def test_get_model_for_view_name(self):
         """
         Test that `get_model_for_view_name` returns the appropriate Model, if the colon separated view name provided.
         """
+        from example_app.models import ExampleModel
+
         with self.subTest("Test core UI view."):
             self.assertEqual(lookup.get_model_for_view_name("dcim:device_list"), dcim_models.Device)
             self.assertEqual(lookup.get_model_for_view_name("dcim:device"), dcim_models.Device)
@@ -459,6 +495,14 @@ class GetFooForModelTest(TestCase):
         # Testing unconventional table name
         self.assertEqual(lookup.get_table_class_string_from_view_name("ipam:prefix_list"), "PrefixDetailTable")
 
+    def test_get_view_titles_for_model(self):
+        view_titles = lookup.get_view_titles_for_model(dcim_models.Device)
+        self.assertEqual(view_titles.titles, dcim_views.DeviceUIViewSet.get_view_titles(dcim_models.Device).titles)
+        view_titles = lookup.get_view_titles_for_model(dcim_models.Device, view_type="")
+        self.assertEqual(
+            view_titles.titles, dcim_views.DeviceUIViewSet.get_view_titles(dcim_models.Device, view_type="").titles
+        )
+
 
 class IsTaggableTest(TestCase):
     def test_is_taggable_true(self):
@@ -1128,6 +1172,29 @@ class TestModuleLoadingUtils(TestCase):
                 self.assertFalse(permitted)
                 self.assertIsInstance(reason, str)
 
+    def test_import_string_optional(self):
+        with self.subTest("Nonexistent module should return None"):
+            self.assertIsNone(import_string_optional("no_such_module.no_such_attribute"))
+            self.assertIsNone(import_string_optional("no_such_module.no_such_submodule.no_such_attribute"))
+            self.assertIsNone(import_string_optional("nautobot.no_such_submodule.no_such_attribute"))
+            self.assertIsNone(import_string_optional("nautobot.core.no_such_submodule.no_such_attribute"))
+
+        with self.subTest("Existing module but nonexistent attribute should return None"):
+            self.assertIsNone(import_string_optional("nautobot.core.no_such_attribute"))
+            self.assertIsNone(import_string_optional("nautobot.core.no_such_attribute"))
+            self.assertIsNone(import_string_optional("sys.no_such_attribute"))
+
+        with self.subTest("Other import errors should propagate upward still"):
+            with self.assertRaises(ImportError):
+                import_string_optional("nautobot.extras.test_jobs.invalid_import.MyJob")
+            with self.assertRaises(ImportError):
+                import_string_optional("nautobot.extras.test_jobs.missing_import.MyJob")
+
+        with self.subTest("Successful imports should succeed"):
+            self.assertEqual(
+                import_string_optional("nautobot.core.tests.test_utils.TestModuleLoadingUtils"), self.__class__
+            )
+
 
 class TestQuerySetUtils(TestCase):
     def test_maybe_select_related(self):

nautobot/core/tests/test_views.py

@@ -1,12 +1,12 @@
 import json
 import os
+from pathlib import Path
 import re
 import tempfile
-from unittest import mock, skipIf
+from unittest import mock
 import urllib.parse
 
 from django.apps import apps
-from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.cache import cache
 from django.core.files.uploadedfile import SimpleUploadedFile
@@ -110,38 +110,25 @@ class HomeViewTestCase(TestCase):
 
         # Search bar in header
         header_search_bar_pattern = re.compile(
-            '<header.*<form action="/search/" class="col text-center" method="get" id="navbar_search" role="search">.*</form>.*</header>'
+            '<header.*<form action="/search/" class="col-4 text-center" id="header_search" method="get" role="search">.*</form>.*</header>'
         )
         header_search_bar_result = header_search_bar_pattern.search(
             response.content.decode(response.charset).replace("\n", "")
         )
 
-        # Global search bar in body/container-fluid wrapper
-        body_search_bar_pattern = re.compile(
-            '<div class="container-fluid wrapper" id="main-content">.*<form action="/search/" method="get" class="form-inline">.*</form>.*</div>',
-            re.DOTALL,
-        )
-
-        body_search_bar_result = body_search_bar_pattern.search(
-            response.content.decode(response.charset).replace("\n", "")
-        )
-
-        return header_search_bar_result, body_search_bar_result
+        return header_search_bar_result
 
     def test_search_bar_not_visible_if_user_not_authenticated(self):
         self.client.logout()
 
-        header_search_bar_result, body_search_bar_result = self.make_request()
+        header_search_bar_result = self.make_request()
 
         self.assertIsNone(header_search_bar_result)
-        self.assertIsNone(body_search_bar_result)
 
-    @tag("fix_in_v3")
     def test_search_bar_visible_if_user_authenticated(self):
-        header_search_bar_result, body_search_bar_result = self.make_request()
+        header_search_bar_result = self.make_request()
 
         self.assertIsNotNone(header_search_bar_result)
-        self.assertIsNotNone(body_search_bar_result)
 
     @override_settings(VERSION="1.2.3")
     def test_footer_version_visible_authenticated_users_only(self):
@@ -190,6 +177,132 @@ class HomeViewTestCase(TestCase):
         self.assertNotIn("Welcome to Nautobot!", response.content.decode(response.charset))
 
 
+class AppDocsViewTestCase(TestCase):
+    def setUp(self):
+        super().setUp()
+        self.test_app_label = "test_app"
+        self.test_base_url = "test-app"
+
+        # Create temp docs dir
+        # I use tearDown to clean up, so this is save
+        self.temp_dir = tempfile.TemporaryDirectory()  # pylint: disable=consider-using-with
+        self.docs_path = Path(self.temp_dir.name) / "docs"
+        self.docs_path.mkdir(parents=True)
+        (self.docs_path / "index.html").write_text("<html>Test Index</html>")
+        (self.docs_path / "css/style.css").parent.mkdir(parents=True, exist_ok=True)
+        (self.docs_path / "css/style.css").write_text("body { background: #fff; }")
+
+    def tearDown(self):
+        self.temp_dir.cleanup()
+        super().tearDown()
+
+    def test_docs_index_redirect(self):
+        """Ensure /docs/<base_url>/ redirects to /docs/<base_url>/index.html."""
+        url = reverse("docs_index_redirect", kwargs={"app_base_url": self.test_base_url})
+        response = self.client.get(url, follow=False)
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(response["Location"], f"/docs/{self.test_base_url}/index.html")
+
+    def test_docs_index_redirect_if_not_logged_in(self):
+        self.client.logout()
+        url = reverse("docs_index_redirect", kwargs={"app_base_url": self.test_base_url})
+        response = self.client.get(url, follow=False)
+
+        # First, the redirect to /docs/<base_url>/index.html
+        self.assertEqual(response.status_code, 302)
+        redirect_url = f"/docs/{self.test_base_url}/index.html"
+        self.assertEqual(response["Location"], redirect_url)
+
+        # Follow the redirect to AppDocsView, which should require login
+        response = self.client.get(redirect_url)
+        self.assertRedirects(
+            response,
+            expected_url=f"{reverse('login')}?next={redirect_url}",
+            status_code=302,
+            target_status_code=200,
+        )
+
+    def test_docs_file_redirect_if_not_logged_in(self):
+        self.client.logout()
+        url = reverse("docs_file", kwargs={"app_base_url": self.test_base_url, "path": "css/style.css"})
+        response = self.client.get(url)
+        # LoginRequiredMixin redirects to /accounts/login/
+        self.assertRedirects(
+            response,
+            expected_url=f"{reverse('login')}?next={url}",
+            status_code=302,
+            target_status_code=200,
+        )
+
+    @mock.patch.dict("nautobot.core.views.BASE_URL_TO_APP_LABEL", {"test-app": "test_app"})
+    @mock.patch("nautobot.core.views.resources.files")
+    def test_access_denied_path_traversal_attempts(self, mock_resources_files):
+        """Ensure ../ or similar traversal patterns are rejected."""
+        mock_resources_files.return_value = Path(self.temp_dir.name)
+
+        malicious_paths = [
+            "../settings.py",
+            "../../etc/passwd",
+            "docs/../../secret.txt",
+        ]
+
+        for path in malicious_paths:
+            with self.subTest(path=path):
+                url = reverse("docs_file", kwargs={"app_base_url": self.test_base_url, "path": path})
+                response = self.client.get(url)
+                self.assertEqual(response.status_code, 403)
+
+    @mock.patch.dict("nautobot.core.views.BASE_URL_TO_APP_LABEL", {"test-app": "test_app"})
+    @mock.patch("nautobot.core.views.resources.files")
+    def test_serve_index_html_logged_in(self, mock_resources_files):
+        mock_resources_files.return_value = Path(self.temp_dir.name)
+        url = reverse("docs_index_redirect", kwargs={"app_base_url": self.test_base_url, "path": "index.html"})
+        response = self.client.get(url, follow=True)
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, "Test Index")
+        self.assertEqual(response["Content-Type"], "text/html")
+
+    @mock.patch.dict("nautobot.core.views.BASE_URL_TO_APP_LABEL", {"test-app": "test_app"})
+    @mock.patch("nautobot.core.views.resources.files")
+    def test_serve_css_logged_in(self, mock_resources_files):
+        mock_resources_files.return_value = Path(self.temp_dir.name)
+        url = reverse("docs_file", kwargs={"app_base_url": self.test_base_url, "path": "css/style.css"})
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, "background: #fff;")
+        self.assertEqual(response["Content-Type"], "text/css")
+
+    @mock.patch.dict("nautobot.core.views.BASE_URL_TO_APP_LABEL", {"test-app": "test_app"})
+    @mock.patch("nautobot.core.views.resources.files")
+    def test_docs_index_nonexistent_app(self, mock_resources_files):
+        mock_resources_files.return_value = Path(self.temp_dir.name)
+        url = reverse("docs_index_redirect", kwargs={"app_base_url": "nonexistent-app"})
+        response = self.client.get(url, follow=True)
+        self.assertEqual(response.status_code, 404)
+        self.assertJSONEqual(response.content, {"detail": "Unknown base_url 'nonexistent-app'."})
+
+    @mock.patch.dict("nautobot.core.views.BASE_URL_TO_APP_LABEL", {"test-app": "test_app"})
+    @mock.patch("nautobot.core.views.resources.files")
+    def test_docs_file_nonexistent_app(self, mock_resources_files):
+        mock_resources_files.return_value = Path(self.temp_dir.name)
+        url = reverse("docs_file", kwargs={"app_base_url": "nonexistent-app", "path": "css/style.css"})
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, 404)
+        self.assertJSONEqual(response.content, {"detail": "Unknown base_url 'nonexistent-app'."})
+
+    @mock.patch.dict("nautobot.core.views.BASE_URL_TO_APP_LABEL", {"test-app": "test_app"})
+    @mock.patch("nautobot.core.views.resources.files")
+    def test_nonexistent_file(self, mock_resources_files):
+        mock_resources_files.return_value = Path(self.temp_dir.name)
+        test_cases = ["/../missing.html", "//../missing.html", "missing.html", "missing_dir/missing.html"]
+        for path in test_cases:
+            with self.subTest(path=path):
+                url = reverse("docs_file", kwargs={"app_base_url": self.test_base_url, "path": path})
+                response = self.client.get(url)
+                self.assertEqual(response.status_code, 404)
+                self.assertIn("File", response.json()["detail"])
+
+
 class MediaViewTestCase(TestCase):
     def test_media_unauthenticated(self):
         """
@@ -270,29 +383,45 @@ class SearchFieldsTestCase(TestCase):
         # SearchForm will redirect the user to the login Page
         self.assertEqual(response.status_code, 302)
 
-    @tag("fix_in_v3")
-    def test_global_and_model_search_bar(self):
+    def test_global_search_bar_scoped_to_model(self):
         self.add_permissions("dcim.view_location", "dcim.view_device")
 
         # Assert model search bar present in list UI
         response = self.client.get(reverse("dcim:location_list"))
         self.assertBodyContains(
             response,
-            '<input type="text" name="q" class="form-control" required placeholder="Search Locations" id="id_q">',
+            '<input aria-placeholder="Press Ctrl+K to search" class="form-control nb-text-transparent" name="q" type="search" value="">',
+            html=True,
+        )
+        self.assertBodyContains(
+            response,
+            """
+                <span class="badge border" data-nb-link="/dcim/locations/"><!--
+                    -->in: Locations<!--
+                    --><button tabindex="-1" type="button">
+                    <span aria-hidden="true" class="mdi mdi-close"></span>
+                    <span class="visually-hidden">Remove</span>
+                </button>
+            """,
             html=True,
         )
 
         response = self.client.get(reverse("dcim:device_list"))
         self.assertBodyContains(
             response,
-            '<input type="text" name="q" class="form-control" required placeholder="Search Devices" id="id_q">',
+            '<input aria-placeholder="Press Ctrl+K to search" class="form-control nb-text-transparent" name="q" type="search" value="">',
             html=True,
         )
-
-        # Assert global search bar present in UI
-        self.assertContains(  # not using assertBodyContains because this is in the nav
+        self.assertBodyContains(
             response,
-            '<input type="text" name="q" class="form-control" placeholder="Search Nautobot">',
+            """
+                <span class="badge border" data-nb-link="/dcim/devices/"><!--
+                    -->in: Devices<!--
+                    --><button tabindex="-1" type="button">
+                    <span aria-hidden="true" class="mdi mdi-close"></span>
+                    <span class="visually-hidden">Remove</span>
+                </button>
+            """,
             html=True,
         )
 
@@ -560,6 +689,7 @@ class MetricsViewTestCase(TestCase):
         page_content = response.content.decode(response.charset)
         return text_string_to_metric_families(page_content)
 
+    @tag("example_app")
     def test_metrics_extensibility(self):
         """Assert that the example metric from the Example App shows up _exactly_ when the app is enabled."""
         test_metric_name = "nautobot_example_metric_count"
@@ -582,6 +712,7 @@ class MetricsViewTestCase(TestCase):
             self.query_and_parse_metrics()
             self.assertTrue(mock_generate_latest_with_cache.call_count == 0)
 
+    @tag("example_app")
     @override_settings(METRICS_EXPERIMENTAL_CACHING_DURATION=30)
     def test_enabled_metrics_cache_enabled(self):
         """Assert that multiple calls to metrics with caching returns expected response."""
@@ -762,10 +893,7 @@ class SilkUIAccessTestCase(TestCase):
 
 
 class ExampleViewWithCustomPermissionsTest(TestCase):
-    @skipIf(
-        "example_app" not in settings.PLUGINS,
-        "example_app not in settings.PLUGINS",
-    )
+    @tag("example_app")
     @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
     def test_permission_classes_attribute_is_enforced(self):
         """