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

nautobot/core/testing/api.py

@@ -17,6 +17,7 @@ from rest_framework import serializers, status
 from rest_framework.relations import ManyRelatedField
 from rest_framework.test import APITransactionTestCase as _APITransactionTestCase
 
+from nautobot.core import constants
 from nautobot.core.api.utils import get_serializer_for_model
 from nautobot.core.models import fields as core_fields
 from nautobot.core.models.tree_queries import TreeModel
@@ -294,8 +295,9 @@ class APIViewTestCases:
             m2m_fields = self.get_m2m_fields()
             self.add_permissions(f"{self.model._meta.app_label}.view_{self.model._meta.model_name}")
             list_url = f"{self._get_list_url()}?depth=0"
+            # With exclude_m2m query parameter set to False
             with CaptureQueriesContext(connections[DEFAULT_DB_ALIAS]) as cqc:
-                response = self.client.get(list_url, **self.header)
+                response = self.client.get(list_url + "&exclude_m2m=false", **self.header)
             base_num_queries = len(cqc)
 
             self.assertHttpStatus(response, status.HTTP_200_OK)
@@ -340,9 +342,9 @@ class APIViewTestCases:
                                 app_label, model_name = object_type.split(".")
                                 ContentType.objects.get(app_label=app_label, model=model_name)
 
-            list_url += "&exclude_m2m=true"
+            # With exclude_m2m query parameter set to True
             with CaptureQueriesContext(connections[DEFAULT_DB_ALIAS]) as cqc:
-                response = self.client.get(list_url, **self.header)
+                response = self.client.get(list_url + "&exclude_m2m=true", **self.header)
 
             self.assertHttpStatus(response, status.HTTP_200_OK)
             self.assertIsInstance(response.data, dict)
@@ -387,8 +389,9 @@ class APIViewTestCases:
             m2m_fields = self.get_m2m_fields()
             self.add_permissions(f"{self.model._meta.app_label}.view_{self.model._meta.model_name}")
             list_url = f"{self._get_list_url()}?depth=1"
+            # With exclude_m2m query parameter set to False
             with CaptureQueriesContext(connections[DEFAULT_DB_ALIAS]) as cqc:
-                response = self.client.get(list_url, **self.header)
+                response = self.client.get(list_url + "&exclude_m2m=false", **self.header)
             base_num_queries = len(cqc)
 
             self.assertHttpStatus(response, status.HTTP_200_OK)
@@ -420,9 +423,9 @@ class APIViewTestCases:
                                 self.assertTrue(is_uuid(response_data[field]["id"]))
                             self.assertGreater(len(response_data[field].keys()), 3, response_data[field])
 
-            list_url += "&exclude_m2m=true"
+            # With exclude_m2m query parameter set to True
             with CaptureQueriesContext(connections[DEFAULT_DB_ALIAS]) as cqc:
-                response = self.client.get(list_url, **self.header)
+                response = self.client.get(list_url + "&exclude_m2m=true", **self.header)
 
             self.assertHttpStatus(response, status.HTTP_200_OK)
             self.assertIsInstance(response.data, dict)
@@ -458,6 +461,54 @@ class APIViewTestCases:
                     self.assertNotIn(field, response_data)
                 # TODO: we should assert that all other fields are still present, but there's a few corner cases...
 
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
+        def test_list_objects_exclude_m2m(self):
+            """
+            GET a list of objects with or without the "exclude_m2m" parameter.
+
+            With exclude_m2m query parameter set to True, we should see no many-to-many fields.
+            With exclude_m2m query parameter set to False, we should see all many-to-many fields.
+            With exclude_m2m query parameter not set, we should only see the default many-to-many fields.
+            """
+            m2m_fields = self.get_m2m_fields()
+            if not m2m_fields:
+                self.skipTest("No many-to-many fields to test")
+            self.add_permissions(f"{self.model._meta.app_label}.view_{self.model._meta.model_name}")
+            list_url = f"{self._get_list_url()}"
+
+            # With exclude_m2m query parameter not set
+            response = self.client.get(list_url, **self.header)
+            self.assertHttpStatus(response, status.HTTP_200_OK)
+            self.assertIsInstance(response.data, dict)
+            self.assertIn("results", response.data)
+
+            for response_data in response.data["results"]:
+                for field in m2m_fields:
+                    if field in constants.DEFAULT_M2M_FIELDS:
+                        self.assertIn(field, response_data)
+                        self.assertIsInstance(response_data[field], list)
+                    else:
+                        self.assertNotIn(field, response_data)
+
+            # With exclude_m2m query parameter set to True
+            response = self.client.get(list_url + "?exclude_m2m=true", **self.header)
+            self.assertHttpStatus(response, status.HTTP_200_OK)
+            self.assertIsInstance(response.data, dict)
+            self.assertIn("results", response.data)
+            for response_data in response.data["results"]:
+                for field in m2m_fields:
+                    self.assertNotIn(field, response_data)
+
+            # With exclude_m2m query parameter set to False
+            response = self.client.get(list_url + "?exclude_m2m=false", **self.header)
+            self.assertHttpStatus(response, status.HTTP_200_OK)
+            self.assertIsInstance(response.data, dict)
+            self.assertIn("results", response.data)
+            for response_data in response.data["results"]:
+                for field in m2m_fields:
+                    self.assertIn(field, response_data)
+                    self.assertIsInstance(response_data[field], list)
+
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_list_objects_without_permission(self):
             """
@@ -1076,12 +1127,20 @@ class APIViewTestCases:
 
             self.assertIn("actions", data)
 
-            # Grab any field that has choices defined (fields with enums)
+            # Grab any field that has choices defined (fields with enums including child fields with enums)
             field_choices = {}
             if "POST" in data["actions"]:
-                field_choices = {k for k, v in data["actions"]["POST"].items() if "choices" in v}
+                field_choices = {
+                    k
+                    for k, v in data["actions"]["POST"].items()
+                    if "choices" in v or ("child" in v and "choices" in v["child"])
+                }
             elif "PUT" in data["actions"]:
-                field_choices = {k for k, v in data["actions"]["PUT"].items() if "choices" in v}
+                field_choices = {
+                    k
+                    for k, v in data["actions"]["PUT"].items()
+                    if "choices" in v or ("child" in v and "choices" in v["child"])
+                }
             else:
                 self.fail(f"Neither PUT nor POST are available actions in: {data['actions']}")
 

nautobot/core/testing/filters.py

@@ -21,7 +21,6 @@ from nautobot.core.filters import (
 )
 from nautobot.core.models.generics import PrimaryModel
 from nautobot.core.testing import views
-from nautobot.core.utils.deprecation import class_deprecated_in_favor_of
 from nautobot.extras.models import Contact, ContactAssociation, Role, Status, Tag, Team
 from nautobot.tenancy import models
 
@@ -435,28 +434,6 @@ class FilterTestCases:
                         ),
                     )
 
-    # Test cases should just explicitly include `name` as a generic_filter_tests entry
-    @class_deprecated_in_favor_of(FilterTestCase)  # pylint: disable=undefined-variable
-    class NameOnlyFilterTestCase(FilterTestCase):
-        """Add simple tests for filtering by name."""
-
-        def test_filters_generic(self):
-            if not any(test[0] == "name" for test in self.generic_filter_tests):
-                self.generic_filter_tests = (["name"], *self.generic_filter_tests)
-            super().test_filters_generic()
-
-    # Test cases should just explicitly include `name` and `slug` as generic_filter_tests entries
-    @class_deprecated_in_favor_of(FilterTestCase)  # pylint: disable=undefined-variable
-    class NameSlugFilterTestCase(FilterTestCase):
-        """Add simple tests for filtering by name and by slug."""
-
-        def test_filters_generic(self):
-            if not any(test[0] == "slug" for test in self.generic_filter_tests):
-                self.generic_filter_tests = (["slug"], *self.generic_filter_tests)
-            if not any(test[0] == "name" for test in self.generic_filter_tests):
-                self.generic_filter_tests = (["name"], *self.generic_filter_tests)
-            super().test_filters_generic()
-
     class TenancyFilterTestCaseMixin(views.TestCase):
         """Add test cases for tenant and tenant-group filters."""
 

nautobot/core/testing/integration.py

@@ -7,7 +7,9 @@ from django.db.models import Model
 from django.test import override_settings, tag
 from django.urls import reverse
 from django.utils.functional import classproperty
+from selenium.webdriver.common.by import By
 from selenium.webdriver.common.keys import Keys
+from selenium.webdriver.support.expected_conditions import element_to_be_clickable
 from selenium.webdriver.support.wait import WebDriverWait
 from splinter.browser import Browser
 from splinter.exceptions import ElementDoesNotExist
@@ -94,7 +96,7 @@ class ObjectsListMixin:
         """
         Click add item button on top of the items table list.
         """
-        self.click_button("#add_button")
+        self.click_button("#add-button")
 
     def click_table_link(self, row=1, column=2):
         """By default, tries to click column next to checkbox to go to the details page."""
@@ -129,7 +131,7 @@ class ObjectDetailsMixin:
         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="card-header"][contains(normalize-space(), "{panel_label}")]/following-sibling::table'
+        panel_xpath = f'//*[@id="main"]//div[contains(@class, "card-header") and contains(normalize-space(), "{panel_label}")]/following-sibling::div[contains(@class, "collapse")]/table'
         value = self.browser.find_by_xpath(f'{panel_xpath}//td[text()="{field_label}"]/following-sibling::td[1]').text
 
         if exact_match:
@@ -144,7 +146,7 @@ class ObjectDetailsMixin:
         TODO: remove after all panels will be moved to UI Components Framework or new Bootstrap 5 templates.
         """
         panel_xpath = f'//*[@id="main"]//div[@class="card-header"][contains(normalize-space(), "{panel_label}")]'
-        expand_button_xpath = f"{panel_xpath}/button[normalize-space()='Expand All']"
+        expand_button_xpath = f"{panel_xpath}/button[normalize-space()='Expand All Groups']"
         expand_button = self.browser.find_by_xpath(expand_button_xpath)
         if not expand_button.is_empty():
             expand_button.click()
@@ -374,10 +376,12 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
         sidenav_button = self.browser.find_by_xpath(f"{section_xpath}/button", wait_time=5)
         if not sidenav_button["aria-expanded"] == "true":
             sidenav_button.click()
-        child_menu_xpath = f"{section_xpath}/div[@class='nb-sidenav-flyout']//a[@class='nb-sidenav-link' and normalize-space()='{child_menu_name}']"
+        child_menu_xpath = f"{section_xpath}/div[@class='nb-sidenav-flyout']//a[contains(@class, 'nb-sidenav-link') and normalize-space()='{child_menu_name}']"
         child_menu = self.browser.find_by_xpath(child_menu_xpath, wait_time=5)
+        old_url = self.browser.url
         child_menu.click()
 
+        WebDriverWait(self.browser, 30).until(lambda driver: driver.url != old_url)
         # Wait for body element to appear
         self.assertTrue(self.browser.is_element_present_by_tag("body", wait_time=5), "Page failed to load")
 
@@ -389,7 +393,7 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
         add_button.click()
 
         # Wait for body element to appear
-        self.assertTrue(self.browser.is_element_present_by_tag("body", wait_time=5), "Page failed to load")
+        self.assertTrue(self.browser.is_element_present_by_name("_create", wait_time=5), "Page failed to load")
 
     def click_edit_form_create_button(self):
         """
@@ -399,7 +403,7 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
         add_button.click()
 
         # Wait for body element to appear
-        self.assertTrue(self.browser.is_element_present_by_tag("body", wait_time=5), "Page failed to load")
+        self.assertTrue(self.browser.is_element_present_by_css(".alert-success", wait_time=5), "Page failed to load")
 
     def _fill_select2_field(self, field_name, value, search_box_class=None):
         """
@@ -453,17 +457,26 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
         search_box.first.type(Keys.ENTER)
 
     def click_button(self, query_selector):
-        btn = self.browser.find_by_css(query_selector, wait_time=5)
+        self.browser.is_element_present_by_css(query_selector, wait_time=5)
         # Button might be visible but on the edge and then impossible to click due to vertical/horizontal scrolls
-        self.browser.execute_script(f"document.querySelector('{query_selector}').scrollIntoView(true)")
+        self.browser.execute_script(
+            f"document.querySelector('{query_selector}').scrollIntoView({{ behavior: 'instant', block: 'start' }});"
+        )
+        # Scrolling may be asynchronous, wait until it's actually clickable.
+        WebDriverWait(self.browser.driver, 30).until(element_to_be_clickable((By.CSS_SELECTOR, query_selector)))
+        btn = self.browser.find_by_css(query_selector)
         btn.click()
 
     def fill_input(self, input_name, input_value):
         """
         Helper function to fill an input field. Solves issue with element could not be scrolled into view for some pages.
         """
-        element = self.browser.find_by_name(input_name, wait_time=5)
-        self.browser.execute_script("arguments[0].scrollIntoView(true);", element.first._element)
+        self.browser.is_element_present_by_name(input_name, wait_time=5)
+        element = self.browser.find_by_name(input_name)
+        self.browser.execute_script(
+            "arguments[0].scrollIntoView({ behavior: 'instant', block: 'start' });", element.first._element
+        )
+        element.is_visible(wait_time=5)
         self.browser.execute_script("arguments[0].focus();", element.first._element)
         self.browser.fill(input_name, input_value)
 

nautobot/core/testing/mixins.py

@@ -19,6 +19,7 @@ from nautobot.core.testing import utils
 from nautobot.core.utils import permissions
 from nautobot.extras import management, models as extras_models
 from nautobot.extras.choices import JobResultStatusChoices
+from nautobot.ipam.models import default_namespace_pk
 from nautobot.users import models as users_models
 
 # Use the proper swappable User model
@@ -81,6 +82,7 @@ class NautobotTestCaseMixin:
         """
         super().tearDown()
         cache.clear()
+        default_namespace_pk.set(None)
 
     def prepare_instance(self, instance):
         """

nautobot/core/testing/views.py

@@ -192,6 +192,10 @@ class ViewTestCases:
             with CaptureQueriesContext(connection) as capture_queries_context:
                 response = self.client.get(instance.get_absolute_url())
             # The object's display name or string representation should appear in the response body
+            # TODO: some models (e.g. JobResult) intentionally do NOT display the full `.display` in the detail view,
+            # but only use the `.name` or `str()`.
+            # This check will always pass in the case where the Example App is installed, because of the banner
+            # it adds, but can/should/may? fail otherwise.
             self.assertBodyContains(response, escape(getattr(instance, "display", str(instance))))
 
             # If any Relationships are defined, they should appear in the response

nautobot/core/tests/integration/test_app_home.py

@@ -1,44 +1,48 @@
+from django.test import tag
+
 from nautobot.circuits.models import Circuit, Provider
 from nautobot.core.testing.integration import SeleniumTestCase
 from nautobot.dcim.models import Location, PowerFeed, PowerPanel
 from nautobot.tenancy.models import Tenant
 
-from example_app.models import ExampleModel
-
 
+@tag("example_app")
 class AppHomeTestCase(SeleniumTestCase):
     """Integration test the Example App homepage extensions."""
 
-    layout = {
-        "Organization": {
-            "Locations": {"model": Location, "permission": "dcim.view_location"},
-            "Example Models": {"model": ExampleModel, "permission": "example_app.view_examplemodel"},
-            "Tenants": {"model": Tenant, "permission": "tenancy.view_tenant"},
-        },
-        "Example App Standard Panel": {
-            "Example App Custom Item": {"permission": "example_app.view_examplemodel"},
-        },
-        "Power": {
-            "Power Feeds": {"model": PowerFeed, "permission": "dcim.view_powerfeed"},
-            "Power Panel": {"model": PowerPanel, "permission": "dcim.view_powerpanel"},
-        },
-        "Circuits": {
-            "Providers": {"model": Provider, "permission": "circuits.view_provider"},
-            "Circuits": {"model": Circuit, "permission": "circuits.view_circuit"},
-        },
-    }
-
-    custom_panel_examplemodel = {
-        "name": "Example App Custom Panel",
-        "items": [
-            "Example 1",
-            "Example 2",
-            "Example 3",
-        ],
-    }
-
     def setUp(self):
         super().setUp()
+
+        from example_app.models import ExampleModel
+
+        self.layout = {
+            "Organization": {
+                "Locations": {"model": Location, "permission": "dcim.view_location"},
+                "Example Models": {"model": ExampleModel, "permission": "example_app.view_examplemodel"},
+                "Tenants": {"model": Tenant, "permission": "tenancy.view_tenant"},
+            },
+            "Example App Standard Panel": {
+                "Example App Custom Item": {"permission": "example_app.view_examplemodel"},
+            },
+            "Power": {
+                "Power Feeds": {"model": PowerFeed, "permission": "dcim.view_powerfeed"},
+                "Power Panel": {"model": PowerPanel, "permission": "dcim.view_powerpanel"},
+            },
+            "Circuits": {
+                "Providers": {"model": Provider, "permission": "circuits.view_provider"},
+                "Circuits": {"model": Circuit, "permission": "circuits.view_circuit"},
+            },
+        }
+
+        self.custom_panel_examplemodel = {
+            "name": "Example App Custom Panel",
+            "items": [
+                "Example 1",
+                "Example 2",
+                "Example 3",
+            ],
+        }
+
         self.login(self.user.username, self.password)
 
     def tearDown(self):

nautobot/core/tests/integration/test_app_navbar.py

@@ -1,6 +1,9 @@
+from django.test import tag
+
 from nautobot.core.testing.integration import SeleniumTestCase
 
 
+@tag("example_app")
 class AppNavBarTestCase(SeleniumTestCase):
     """Integration test the navigation menu."""
 

nautobot/core/tests/nautobot_config_without_example_apps.py

@@ -0,0 +1,4 @@
+from nautobot.core.tests.nautobot_config import *  # noqa: F403
+
+# Do not enable example apps
+PLUGINS = []

nautobot/core/tests/runner.py

@@ -39,11 +39,12 @@ class NautobotParallelTestSuite(ParallelTestSuite):
 
 class NautobotTestRunner(DiscoverRunner):
     """
-    Custom test runner that excludes (slow) integration and migration tests by default.
+    Custom test runner that excludes (slow) integration and migration tests by default among others.
 
     This test runner is aware of our use of the "integration" tag and only runs integration tests if
     explicitly passed in with `nautobot-server test --tag integration`.
     Similarly, it only runs migration tests if explicitly called with `--tag migration_test`.
+    Similarly, it only runs tests that require the example app(s) if those are present in settings.PLUGINS.
 
     By Nautobot convention, integration tests must be tagged with "integration". The base
     `nautobot.core.testing.integration.SeleniumTestCase` has this tag, therefore any test cases
@@ -58,6 +59,10 @@ class NautobotTestRunner(DiscoverRunner):
     parallel_test_suite = NautobotParallelTestSuite
 
     exclude_tags = ["integration", "migration_test"]
+    if "example_app" not in settings.PLUGINS:
+        exclude_tags.append("example_app")
+    if "example_app_with_view_override" not in settings.PLUGINS:
+        exclude_tags.append("example_app_with_view_override")
 
     @classmethod
     def add_arguments(cls, parser):
@@ -157,6 +162,9 @@ class NautobotTestRunner(DiscoverRunner):
                             db_command = [*command, "--database", alias]
                             call_command(*db_command)
 
+                        # Calculate membership for the dynamic groups that were generated by the factories/fixtures
+                        call_command("refresh_dynamic_group_member_caches")
+
                     if self.parallel > 1:
                         for index in range(self.parallel):
                             with time_keeper.timed(f"  Cloning '{alias}'"):

nautobot/core/tests/test_api.py

@@ -533,10 +533,12 @@ class ModelViewSetMixinTest(testing.APITestCase):
         self.user.is_superuser = True
         self.user.save()
 
-        # Default behavior - m2m fields included
+        # With exclude_m2m query parameter set to False
         view = self.SimpleIPAddressViewSet()
         view.action_map = {"get": "list"}
-        request = APIRequestFactory().get(reverse("ipam-api:ipaddress-list"), headers=self.header)
+        request = APIRequestFactory().get(
+            reverse("ipam-api:ipaddress-list"), headers=self.header, data={"exclude_m2m": False}
+        )
         force_authenticate(request, user=self.user)
         request = view.initialize_request(request)
         view.setup(request)
@@ -561,7 +563,7 @@ class ModelViewSetMixinTest(testing.APITestCase):
             list(instance.vm_interfaces.all())
             list(instance.tags.all())
 
-        # With exclude_m2m query parameter
+        # With exclude_m2m query parameter set to True
         view = self.SimpleIPAddressViewSet()
         view.action_map = {"get": "list"}
         request = APIRequestFactory().get(

nautobot/core/tests/test_breadcrumbs.py

@@ -296,8 +296,8 @@ class BreadcrumbsTestCase(TestCase):
         breadcrumbs = Breadcrumbs()
 
         # Should have defaults for list and details
-        self.assertEqual(len(breadcrumbs.items["list"]), 2)
-        self.assertEqual(len(breadcrumbs.items["detail"]), 3)
+        self.assertEqual(len(breadcrumbs.items["list"]), 0)
+        self.assertEqual(len(breadcrumbs.items["detail"]), 2)
 
         # Verify adding items
         new_item = BaseBreadcrumbItem()
@@ -306,7 +306,7 @@ class BreadcrumbsTestCase(TestCase):
         self.assertEqual(len(breadcrumbs.items["list"]), 1)
         self.assertEqual(breadcrumbs.items["list"][0], new_item)
 
-        self.assertEqual(len(breadcrumbs.items["detail"]), 2)
+        self.assertEqual(len(breadcrumbs.items["detail"]), 1)
         self.assertEqual(breadcrumbs.items["detail"][0], new_item)
 
         self.assertEqual(len(breadcrumbs.items["custom_action"]), 1)
@@ -325,7 +325,7 @@ class BreadcrumbsTestCase(TestCase):
 
         # Other defaults should still exist
         self.assertIn("detail", breadcrumbs.items)
-        self.assertEqual(len(breadcrumbs.items["detail"]), 3)
+        self.assertEqual(len(breadcrumbs.items["detail"]), 2)
 
     def test_get_items_from_action_static_method(self):
         """Test the _get_items_from_action static method."""
@@ -355,7 +355,6 @@ class BreadcrumbsTestCase(TestCase):
         breadcrumbs = Breadcrumbs()
         expected_items = [
             ("/dcim/location-types/", "Location Types"),
-            (f"/dcim/location-types/{self.location_type.pk}/", str(self.location_type)),
         ]
 
         # Test with an action that doesn't exist but detail=True
@@ -366,13 +365,13 @@ class BreadcrumbsTestCase(TestCase):
         items = breadcrumbs.get_breadcrumbs_items(context)
 
         # Should get 2 items from detail fallback
-        self.assertEqual(len(items), 2)
+        self.assertEqual(len(items), 1)
         self.assertEqual(items, expected_items)
 
     def test_render_method(self):
         """Test the render method."""
         breadcrumbs = Breadcrumbs()
-        context = Context({"view_action": "list", "model": Device})
+        context = Context({"detail": True, "model": Device})
 
         html = breadcrumbs.render(context)
 

nautobot/core/tests/test_checks.py

@@ -1,6 +1,7 @@
 from django.test import override_settings, TestCase
 
 from nautobot.core import checks
+from nautobot.dcim.choices import DeviceUniquenessChoices
 
 
 class CheckCoreSettingsTest(TestCase):
@@ -42,3 +43,30 @@ class CheckCoreSettingsTest(TestCase):
     def test_check_maintenance_mode(self):
         """Error if MAINTENANCE_MODE is set and yet SESSION_ENGINE is still storing sessions in the db."""
         self.assertEqual(checks.check_maintenance_mode(None), [checks.E005])
+
+    @override_settings(
+        DEVICE_NAME_AS_NATURAL_KEY=True,
+    )
+    def test_check_deprecated_device_name_as_natural_key(self):
+        """Warn if DEVICE_NAME_AS_NATURAL_KEY is defined in settings."""
+        self.assertEqual(
+            checks.check_deprecated_device_name_as_natural_key(None),
+            [checks.W006],
+        )
+
+    @override_settings(
+        DEVICE_UNIQUENESS="invalid_value",
+    )
+    def test_check_invalid_device_uniqueness_value(self):
+        """Warn if DEVICE_UNIQUENESS is set to an invalid value."""
+        self.assertEqual(
+            checks.check_valid_value_for_device_uniqueness(None),
+            [checks.W007],
+        )
+
+    @override_settings(
+        DEVICE_UNIQUENESS=DeviceUniquenessChoices.NAME,
+    )
+    def test_check_valid_device_uniqueness_value(self):
+        """No warning if DEVICE_UNIQUENESS is set to a valid value."""
+        self.assertEqual(checks.check_valid_value_for_device_uniqueness(None), [])

nautobot/core/tests/test_cli.py

@@ -0,0 +1,40 @@
+from nautobot.core.cli import migrate_deprecated_templates
+from nautobot.core.testing import TestCase
+
+
+class TestMigrateTemplates(TestCase):
+    def test_template_replacements(self):
+        """Verify that all old templates are replaced by a single new template."""
+        audit_dict = {}
+        for new_template, old_templates in migrate_deprecated_templates.TEMPLATE_REPLACEMENTS.items():
+            for old_template in old_templates:
+                self.assertNotIn(old_template, audit_dict)
+                audit_dict[old_template] = new_template
+
+    def test_replace_template_references_no_change(self):
+        content = """
+        {% extends "base.html" %}
+        {% block content %}
+        <h1>Hello, World!</h1>
+        {% endblock %}
+        """
+        replaced_content, was_updated = migrate_deprecated_templates.replace_template_references(content)
+        self.assertFalse(was_updated)
+        self.assertEqual(replaced_content, content)
+
+    def test_replace_template_references(self):
+        original_content = """
+        {% extends "generic/object_bulk_import.html" %}
+        {% block content %}
+        <h1>Hello, World!</h1>
+        {% endblock %}
+        """
+        new_content = """
+        {% extends "generic/object_bulk_create.html" %}
+        {% block content %}
+        <h1>Hello, World!</h1>
+        {% endblock %}
+        """
+        replaced_content, was_updated = migrate_deprecated_templates.replace_template_references(original_content)
+        self.assertTrue(was_updated)
+        self.assertEqual(replaced_content, new_content)

nautobot/core/tests/test_config.py

@@ -1,7 +1,7 @@
 """Test cases for nautobot.core.config module."""
 
 from constance.test import override_config
-from django.test import override_settings, TestCase
+from django.test import override_settings, tag, TestCase
 
 from nautobot.apps import config as app_config
 from nautobot.core.utils import config
@@ -37,6 +37,7 @@ class GetSettingsOrConfigTestCase(TestCase):
         self.assertRaises(AttributeError, config.get_settings_or_config, "FAKE_SETTING")
 
 
+@tag("example_app")
 class GetAppSettingsOrConfigTestCase(TestCase):
     """Test the get_app_settings_or_config() helper function."""