nautobot 2.0.0a2__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

nautobot/core/tests/test_logging.py

@@ -3,7 +3,6 @@ from nautobot.core.utils import logging
 
 
 class LoggingUtilitiesTest(testing.TestCase):
-
     DIRTY_CLEAN = (
         # should match first default pattern
         ("http://user:password@localhost", "http://(redacted)@localhost"),
@@ -18,6 +17,10 @@ class LoggingUtilitiesTest(testing.TestCase):
             "I use username FOO and password BAR to log in as https://FOO:BAR@example.com",
             "I use username (redacted) and password (redacted) to log in as https://(redacted)@example.com",
         ),
+        ("Password is1234", "Password (redacted)"),
+        ("Password: is1234", "Password: (redacted)"),
+        ("Password is: is1234", "Password is: (redacted)"),
+        ("Password is is1234", "Password is (redacted)"),
     )
 
     def test_sanitize_default_coverage(self):

nautobot/core/tests/test_managers.py

@@ -1,6 +1,7 @@
 from django.test import TestCase
 
 from nautobot.dcim import models
+from nautobot.extras import models as extras_models
 
 
 class NaturalOrderByManagerTest(TestCase):
@@ -12,11 +13,11 @@ class NaturalOrderByManagerTest(TestCase):
         return
 
     def evaluate_ordering(self, names):
-
         # Create the Racks
         location_type = models.LocationType.objects.get(name="Campus")
         location = models.Location.objects.filter(location_type=location_type).first()
-        models.Rack.objects.bulk_create(models.Rack(name=name, location=location) for name in names)
+        status = extras_models.Status.objects.get_for_model(models.Rack).first()
+        models.Rack.objects.bulk_create(models.Rack(name=name, location=location, status=status) for name in names)
         # Validate forward ordering
         self.assertEqual(names, list(models.Rack.objects.filter(name__in=names).values_list("name", flat=True)))
 
@@ -27,7 +28,6 @@ class NaturalOrderByManagerTest(TestCase):
         )
 
     def test_leading_digits(self):
-
         self.evaluate_ordering(
             [
                 "1Alpha",
@@ -52,7 +52,6 @@ class NaturalOrderByManagerTest(TestCase):
         )
 
     def test_trailing_digits(self):
-
         self.evaluate_ordering(
             [
                 "Alpha1",
@@ -77,7 +76,6 @@ class NaturalOrderByManagerTest(TestCase):
         )
 
     def test_leading_and_trailing_digits(self):
-
         self.evaluate_ordering(
             [
                 "1Alpha1",

nautobot/core/tests/test_models.py

@@ -1,4 +1,5 @@
 from django.core.exceptions import ValidationError
+from django.test.utils import isolate_apps
 
 from nautobot.core.models import BaseModel
 from nautobot.core.models.utils import construct_natural_key_slug, deconstruct_natural_key_slug
@@ -6,6 +7,7 @@ from nautobot.core.testing import TestCase
 from nautobot.dcim.models import DeviceType, Manufacturer
 
 
+@isolate_apps("nautobot.core.tests")
 class BaseModelTest(TestCase):
     class FakeBaseModel(BaseModel):
         def clean(self):

nautobot/core/tests/test_ordering.py

@@ -9,7 +9,6 @@ class NaturalizationTestCase(TestCase):
     """
 
     def test_naturalize(self):
-
         # Original, naturalized
         data = (
             ("abc", "abc"),
@@ -28,7 +27,6 @@ class NaturalizationTestCase(TestCase):
         self.assertEqual(ordering.naturalize("abc123def456", max_length=10), "abc0000012")
 
     def test_naturalize_interface(self):
-
         # Original, naturalized
         data = (
             # IOS/JunOS-style

nautobot/core/tests/test_paginator.py

@@ -9,6 +9,7 @@ from django.urls import reverse
 from nautobot.core import testing
 from nautobot.core.views import paginator
 from nautobot.dcim import models
+from nautobot.extras import models as extras_models
 
 
 class PaginatorTestCase(testing.TestCase):
@@ -52,8 +53,9 @@ class PaginatorTestCase(testing.TestCase):
     def test_enforce_max_page_size(self):
         """Request an object list view and assert that the MAX_PAGE_SIZE setting is enforced"""
         location_type = models.LocationType.objects.get(name="Campus")
+        status = extras_models.Status.objects.get_for_model(models.Location).first()
         models.Location.objects.bulk_create(
-            [models.Location(name=f"TestLocation{x}", location_type=location_type) for x in range(20)]
+            [models.Location(name=f"TestLocation{x}", location_type=location_type, status=status) for x in range(20)]
         )
         url = reverse("dcim:location_list")
         self.add_permissions("dcim.view_location")

nautobot/core/tests/test_releases.py

@@ -3,8 +3,8 @@ from logging import ERROR
 from unittest.mock import Mock, patch
 
 import requests
-from cacheops import CacheMiss, RedisCache
 from django.conf import settings
+from django.core.cache import cache
 from django.test import SimpleTestCase, override_settings
 from packaging import version
 from requests import Response
@@ -67,10 +67,10 @@ def unsuccessful_github_response(url, *_args, **_kwargs):
 )
 class GetReleasesTestCase(SimpleTestCase):
     @patch.object(requests, "get")
-    @patch.object(RedisCache, "set")
-    @patch.object(RedisCache, "get")
+    @patch.object(cache, "set")
+    @patch.object(cache, "get")
     def test_pre_releases(self, mock_cache_get: Mock, mock_cache_set: Mock, mock_request_get: Mock):
-        mock_cache_get.side_effect = CacheMiss()
+        mock_cache_get.return_value = None
         mock_request_get.side_effect = successful_github_response
 
         releases = get_releases(pre_releases=True)
@@ -108,10 +108,10 @@ class GetReleasesTestCase(SimpleTestCase):
         mock_cache_set.assert_called_once_with("latest_release", (expected_version, expected_url), 160876)
 
     @patch.object(requests, "get")
-    @patch.object(RedisCache, "set")
-    @patch.object(RedisCache, "get")
+    @patch.object(cache, "set")
+    @patch.object(cache, "get")
     def test_no_pre_releases(self, mock_cache_get: Mock, mock_cache_set: Mock, mock_request_get: Mock):
-        mock_cache_get.side_effect = CacheMiss()
+        mock_cache_get.return_value = None
         mock_request_get.side_effect = successful_github_response
 
         releases = get_releases(pre_releases=False)
@@ -145,10 +145,10 @@ class GetReleasesTestCase(SimpleTestCase):
         mock_cache_set.assert_called_once_with("latest_release", (expected_version, expected_url), 160876)
 
     @patch.object(requests, "get")
-    @patch.object(RedisCache, "set")
-    @patch.object(RedisCache, "get")
+    @patch.object(cache, "set")
+    @patch.object(cache, "get")
     def test_failed_request(self, mock_cache_get: Mock, mock_cache_set: Mock, mock_request_get: Mock):
-        mock_cache_get.side_effect = CacheMiss()
+        mock_cache_get.return_value = None
         mock_request_get.side_effect = unsuccessful_github_response
 
         with self.assertLogs(level=ERROR) as cm:
@@ -175,8 +175,8 @@ class GetReleasesTestCase(SimpleTestCase):
         mock_cache_set.assert_called_once_with("latest_release_no_retry", "https://localhost/unittest/releases", 900)
 
     @patch.object(requests, "get")
-    @patch.object(RedisCache, "set")
-    @patch.object(RedisCache, "get")
+    @patch.object(cache, "set")
+    @patch.object(cache, "get")
     def test_blocked_retry(self, mock_cache_get: Mock, mock_cache_set: Mock, mock_request_get: Mock):
         mock_cache_get.return_value = "https://localhost/unittest/releases"
         mock_request_get.side_effect = successful_github_response

nautobot/core/tests/test_templatetags_helpers.py

@@ -23,25 +23,28 @@ class NautobotTemplatetagsHelperTest(TestCase):
         self.assertEqual(helpers.hyperlinked_object("hello"), "hello")
         # An object with get_absolute_url gives a hyperlink
         location = models.Location.objects.first()
+        # Initially remove description if any
+        location.description = ""
+        location.save()
         self.assertEqual(
-            helpers.hyperlinked_object(location), f'<a href="/dcim/locations/{location.slug}/">{location.name}</a>'
+            helpers.hyperlinked_object(location), f'<a href="/dcim/locations/{location.pk}/">{location.name}</a>'
         )
         # An object with get_absolute_url and a description gives a titled hyperlink
         location.description = "An important location"
         location.save()
         self.assertEqual(
             helpers.hyperlinked_object(location),
-            f'<a href="/dcim/locations/{location.slug}/" title="An important location">{location.name}</a>',
+            f'<a href="/dcim/locations/{location.pk}/" title="An important location">{location.name}</a>',
         )
         # Optionally you can request a field other than the object's display string
         self.assertEqual(
             helpers.hyperlinked_object(location, "slug"),
-            f'<a href="/dcim/locations/{location.slug}/" title="An important location">{location.slug}</a>',
+            f'<a href="/dcim/locations/{location.pk}/" title="An important location">{location.slug}</a>',
         )
         # If you request a nonexistent field, it defaults to the string representation
         self.assertEqual(
             helpers.hyperlinked_object(location, "foo"),
-            f'<a href="/dcim/locations/{location.slug}/" title="An important location">{location!s}</a>',
+            f'<a href="/dcim/locations/{location.pk}/" title="An important location">{location!s}</a>',
         )
 
     def test_placeholder(self):

nautobot/core/tests/test_utils.py

@@ -1,16 +1,16 @@
-import pickle
+import uuid
 
 from django import forms as django_forms
 from django.contrib.auth.models import Group
 from django.contrib.contenttypes.models import ContentType
 from django.db.models import Q
 from django.http import QueryDict
-from django.test import RequestFactory, TestCase
+from django.test import TestCase
 
 from example_plugin.models import ExampleModel
 
 from nautobot.circuits import models as circuits_models
-from nautobot.core import constants, exceptions, forms, settings_funcs, testing
+from nautobot.core import exceptions, forms, settings_funcs
 from nautobot.core.api import utils as api_utils
 from nautobot.core.models import fields as core_fields, utils as models_utils
 from nautobot.core.utils import data as data_utils, filtering, lookup, requests
@@ -20,6 +20,7 @@ from nautobot.dcim import models as dcim_models
 from nautobot.dcim import tables
 from nautobot.extras import models as extras_models
 from nautobot.extras import utils as extras_utils
+from nautobot.extras.choices import RelationshipTypeChoices
 
 
 class DictToFilterParamsTest(TestCase):
@@ -285,12 +286,12 @@ class PrettyPrintQueryTest(TestCase):
         # TODO: Remove pylint disable after issue is resolved (see: https://github.com/PyCQA/pylint/issues/7381)
         # pylint: disable=unsupported-binary-operation
         queries = [
-            ((Q(location__slug="ams01") | Q(location__slug="ang01")) & ~Q(status__slug="active"))
-            | Q(status__slug="planned"),
-            (Q(location__slug="ams01") | Q(location__slug="ang01")) & ~Q(status__slug="active"),
+            ((Q(location__slug="ams01") | Q(location__slug="ang01")) & ~Q(status__name="Active"))
+            | Q(status__name="Planned"),
+            (Q(location__slug="ams01") | Q(location__slug="ang01")) & ~Q(status__name="Active"),
             Q(location__slug="ams01") | Q(location__slug="ang01"),
-            Q(location__slug="ang01") & ~Q(status__slug="active"),
-            Q(location__slug="ams01", status__slug="planned"),
+            Q(location__slug="ang01") & ~Q(status__name="Active"),
+            Q(location__slug="ams01", status__name="Planned"),
             Q(location__slug="ang01"),
             Q(status__id=12345),
             Q(location__slug__in=["ams01", "ang01"]),
@@ -303,16 +304,16 @@ class PrettyPrintQueryTest(TestCase):
     (
       location__slug='ams01' OR location__slug='ang01'
     ) AND (
-      NOT (status__slug='active')
+      NOT (status__name='Active')
     )
-  ) OR status__slug='planned'
+  ) OR status__name='Planned'
 )""",
             """\
 (
   (
     location__slug='ams01' OR location__slug='ang01'
   ) AND (
-    NOT (status__slug='active')
+    NOT (status__name='Active')
   )
 )""",
             """\
@@ -322,12 +323,12 @@ class PrettyPrintQueryTest(TestCase):
             """\
 (
   location__slug='ang01' AND (
-    NOT (status__slug='active')
+    NOT (status__name='Active')
   )
 )""",
             """\
 (
-  location__slug='ams01' AND status__slug='planned'
+  location__slug='ams01' AND status__name='Planned'
 )""",
             """\
 (
@@ -376,17 +377,17 @@ class LookupRelatedFunctionTest(TestCase):
         """
         Assert that is_single_choice_field() correctly distinguishes between single-value and multi-value filter fields.
         """
-        filterset_class = dcim_filters.LocationFilterSet
+        location_filterset = dcim_filters.LocationFilterSet()
 
         single_choice_fields = ("has_vlans", "has_clusters")
         for field in single_choice_fields:
             with self.subTest(f"Single choice field: {field}"):
-                self.assertTrue(requests.is_single_choice_field(filterset_class, field))
+                self.assertTrue(requests.is_single_choice_field(location_filterset, field))
 
         multi_choice_fields = ("created", "status", "tenant", "tags")
         for field in multi_choice_fields:
             with self.subTest(f"Multi choice field: {field}"):
-                self.assertFalse(requests.is_single_choice_field(filterset_class, field))
+                self.assertFalse(requests.is_single_choice_field(location_filterset, field))
 
     def test_build_lookup_label(self):
         with self.subTest():
@@ -422,13 +423,14 @@ class LookupRelatedFunctionTest(TestCase):
             self.assertEqual(str(err.exception), "field_name not found")
 
     def test_get_filterset_field(self):
+        location_filterset = dcim_filters.LocationFilterSet()
         with self.subTest():
-            field = filtering.get_filterset_field(dcim_filters.LocationFilterSet, "name")
-            self.assertEqual(field.__class__, dcim_filters.LocationFilterSet().filters.get("name").__class__)
+            field = filtering.get_filterset_field(location_filterset, "name")
+            self.assertEqual(field.__class__, location_filterset.filters.get("name").__class__)
 
         with self.subTest("Test invalid field"):
             with self.assertRaises(exceptions.FilterSetFieldNotFound) as err:
-                filtering.get_filterset_field(dcim_filters.LocationFilterSet, "unknown")
+                filtering.get_filterset_field(location_filterset, "unknown")
             self.assertEqual(str(err.exception), "unknown is not a valid LocationFilterSet field")
 
     def test_get_filterset_parameter_form_field(self):
@@ -508,6 +510,8 @@ class LookupRelatedFunctionTest(TestCase):
             self.assertEqual(form_field.queryset.count(), extras_utils.ChangeLoggedModelsQuery().as_queryset().count())
 
     def test_convert_querydict_to_factory_formset_dict(self):
+        location_filter_set = dcim_filters.LocationFilterSet()
+
         with self.subTest("Convert QueryDict to an acceptable factory formset QueryDict and discards invalid params"):
             request_querydict = QueryDict(mutable=True)
             request_querydict.setlistdefault("status", ["active", "decommissioning"])
@@ -516,7 +520,7 @@ class LookupRelatedFunctionTest(TestCase):
             request_querydict.setlistdefault("name__iew", [""])  # Should be ignored since it has no value
 
             data = requests.convert_querydict_to_factory_formset_acceptable_querydict(
-                request_querydict, dcim_filters.LocationFilterSet
+                request_querydict, location_filter_set
             )
             expected_querydict = QueryDict(mutable=True)
             expected_querydict.setlistdefault("form-TOTAL_FORMS", [3])
@@ -536,7 +540,7 @@ class LookupRelatedFunctionTest(TestCase):
             request_querydict = QueryDict(mutable=True)
 
             data = requests.convert_querydict_to_factory_formset_acceptable_querydict(
-                request_querydict, dcim_filters.LocationFilterSet
+                request_querydict, location_filter_set
             )
             expected_querydict = QueryDict(mutable=True)
             expected_querydict.setlistdefault("form-TOTAL_FORMS", [3])
@@ -552,7 +556,7 @@ class LookupRelatedFunctionTest(TestCase):
             request_querydict.setlistdefault("q", "location")  # Should be ignored
 
             data = requests.convert_querydict_to_factory_formset_acceptable_querydict(
-                request_querydict, dcim_filters.LocationFilterSet
+                request_querydict, location_filter_set
             )
             expected_querydict = QueryDict(mutable=True)
             expected_querydict.setlistdefault("form-TOTAL_FORMS", [3])
@@ -571,8 +575,9 @@ class LookupRelatedFunctionTest(TestCase):
         filter_params.setlistdefault("status", ["active", "planned"])
 
         non_filter_params = ["page", "per_page"]
-        filterset_class = dcim_filters.LocationFilterSet
-        data = requests.get_filterable_params_from_filter_params(filter_params, non_filter_params, filterset_class)
+        data = requests.get_filterable_params_from_filter_params(
+            filter_params, non_filter_params, dcim_filters.LocationFilterSet()
+        )
 
         self.assertEqual(data, {"name": ["Location 1"], "status": ["active", "planned"]})
 
@@ -590,57 +595,86 @@ class LookupRelatedFunctionTest(TestCase):
         self.assertEqual(err.exception.code, 404)
 
 
-class NautobotFakeRequestTest(testing.TestCase):
-    """Test the NautobotFakeRequest class."""
-
-    def setUp(self):
-        """Create the RequestFactory."""
-        super().setUp()
-        self.factory = RequestFactory()
-
-    def get_with_user(self, url):
-        """RequestFactory() doesn't run middleware, so simulate it."""
-        request = self.factory.get(url)
-        request.user = self.user
-        return request
-
-    def test_copy_safe_request(self):
-        """Test that copy_safe_request() produces a realistic looking NautobotFakeRequest."""
-        real_request = self.get_with_user("/")
-        fake_request = requests.copy_safe_request(real_request)
-        self.assertEqual(real_request.POST, fake_request.POST)
-        self.assertEqual(real_request.GET, fake_request.GET)
-        self.assertEqual(real_request.user, fake_request.user)
-        self.assertEqual(real_request.path, fake_request.path)
-        for key in fake_request.META.keys():
-            self.assertIn(key, constants.HTTP_REQUEST_META_SAFE_COPY)
-            self.assertEqual(real_request.META[key], fake_request.META[key])
-        self.assertEqual(fake_request.user, self.user)
-
-    def test_fake_request_json_no_extra_db_access(self):
-        """Verify that serializing and deserializing a NautobotFakeRequest as JSON doesn't unnecessarily access the DB."""
-        real_request = self.get_with_user("/")
-        fake_request = requests.copy_safe_request(real_request)
-        with self.assertNumQueries(0):
-            new_fake_request = requests.NautobotFakeRequest.nautobot_deserialize(fake_request.nautobot_serialize())
-        # After creating the new instance, its `user` is a lazy attribute, which should evaluate on demand:
-        with self.assertNumQueries(1):
-            new_fake_request.user
-            self.assertEqual(new_fake_request.user, self.user)
-        # It should then be cached and not require re-lookup from the DB
-        with self.assertNumQueries(0):
-            new_fake_request.user
-
-    def test_fake_request_pickle_no_extra_db_access(self):
-        """Verify that pickling and unpickling a NautobotFakeRequest doesn't unnecessarily access the DB."""
-        real_request = self.get_with_user("/")
-        fake_request = requests.copy_safe_request(real_request)
-        with self.assertNumQueries(0):
-            new_fake_request = pickle.loads(pickle.dumps(fake_request))
-        # After creating the new instance, its `user` is a lazy attribute, which should evaluate on demand:
-        with self.assertNumQueries(1):
-            new_fake_request.user
-            self.assertEqual(new_fake_request.user, self.user)
-        # It should then be cached and not require re-lookup from the DB
-        with self.assertNumQueries(0):
-            new_fake_request.user
+class GetFilterFieldLabelTest(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        device_ct = ContentType.objects.get_for_model(dcim_models.Device)
+        cls.peer_relationship = extras_models.Relationship(
+            label="HA Device Peer",
+            key="ha_device_peer",
+            source_type=device_ct,
+            destination_type=device_ct,
+            source_label="Peer",
+            destination_label="Peer",
+            type=RelationshipTypeChoices.TYPE_ONE_TO_ONE_SYMMETRIC,
+        )
+        cls.peer_relationship.validated_save()
+
+        cls.custom_field = extras_models.CustomField(key="labeled_custom_field", label="Moo!", type="text")
+        cls.custom_field.validated_save()
+        cls.custom_field.content_types.add(device_ct)
+
+    def test_get_filter_field_label(self):
+        """Validate the operation of get_filter_field_label()."""
+
+        device_filter_set_filters = dcim_filters.DeviceFilterSet().filters
+
+        with self.subTest("Simple field name"):
+            self.assertEqual(filtering.get_filter_field_label(device_filter_set_filters["id"]), "Id")
+
+        with self.subTest("Semi-complex field name"):
+            self.assertEqual(
+                filtering.get_filter_field_label(device_filter_set_filters["has_interfaces"]), "Has interfaces"
+            )
+
+        with self.subTest("Relationship field name"):
+            self.assertEqual(
+                filtering.get_filter_field_label(device_filter_set_filters[f"cr_{self.peer_relationship.key}__peer"]),
+                self.peer_relationship.source_label,
+            )
+
+        with self.subTest("Custom field with label"):
+            self.assertEqual(
+                filtering.get_filter_field_label(device_filter_set_filters[f"cf_{self.custom_field.key}"]),
+                "Moo!",
+            )
+
+
+class FieldNameToDisplayTest(TestCase):
+    def test__field_name_to_display(self):
+        """Validate the operation of _field_name_to_display()."""
+
+        with self.subTest("id => Id"):
+            self.assertEqual(filtering._field_name_to_display("id"), "Id")
+
+        with self.subTest("device_type => Device Type"):
+            self.assertEqual(filtering._field_name_to_display("device_type"), "Device type")
+
+        with self.subTest("_custom_field_data__site_type => Site Type"):
+            self.assertEqual(filtering._field_name_to_display("_custom_field_data__site_type"), "Site type")
+
+        with self.subTest("cr_sister_sites__peer => Peer"):
+            # This shouldn't ever be an input because get_filter_field_label
+            # will use the label from the custom field instead of the field name
+            self.assertEqual(filtering._field_name_to_display("cr_sister_sites__peer"), "Cr_sister_sites peer")
+
+
+class IsFooTest(TestCase):
+    def test_is_url(self):
+        """Validate the operation of `is_url()`."""
+        with self.subTest("Test a valid URL."):
+            self.assertTrue(
+                data_utils.is_url("http://localhost:3000/api/extras/statuses/3256ead7-0745-432a-a031-3928c9b7d075/")
+            )
+        with self.subTest("Test an nvalid URL."):
+            self.assertFalse(data_utils.is_url("pizza"))
+
+    def test_is_uuid(self):
+        """Validate the operation of `is_uuid()`."""
+        with self.subTest("Test valid UUID."):
+            self.assertTrue(data_utils.is_uuid(uuid.uuid4()))
+            self.assertTrue(data_utils.is_uuid(str(uuid.uuid4())))
+        with self.subTest("Test invalid UUID."):
+            self.assertFalse(data_utils.is_uuid(None))
+            self.assertFalse(data_utils.is_uuid(1))
+            self.assertFalse(data_utils.is_uuid("abc123"))

nautobot/core/tests/test_views.py

@@ -12,14 +12,12 @@ from nautobot.extras.registry import registry
 
 class HomeViewTestCase(TestCase):
     def test_home(self):
-
         url = reverse("home")
 
         response = self.client.get(url)
         self.assertHttpStatus(response, 200)
 
     def test_search(self):
-
         url = reverse("search")
         params = {
             "q": "foo",
@@ -189,8 +187,8 @@ class NavRestrictedUI(TestCase):
         return response.content.decode(response.charset)
 
     @override_settings(HIDE_RESTRICTED_UI=True)
-    def test_installed_plugins_visible_to_staff_with_hide_restricted_ui_true(self):
-        """The "Installed Plugins" menu item should be available to is_staff user regardless of HIDE_RESTRICTED_UI."""
+    def test_installed_apps_visible_to_staff_with_hide_restricted_ui_true(self):
+        """The "Installed Apps" menu item should be available to is_staff user regardless of HIDE_RESTRICTED_UI."""
         # Make user admin
         self.user.is_staff = True
         self.user.save()
@@ -199,16 +197,15 @@ class NavRestrictedUI(TestCase):
         self.assertInHTML(
             f"""
             <li>
-              <div class="buttons pull-right"></div>
-              <a href="{self.url}" data-item-weight="{self.item_weight}">Installed Plugins</a>
+              <a href="{self.url}" data-item-weight="{self.item_weight}">Installed Apps</a>
             </li>
             """,
             response_content,
         )
 
     @override_settings(HIDE_RESTRICTED_UI=False)
-    def test_installed_plugins_visible_to_staff_with_hide_restricted_ui_false(self):
-        """The "Installed Plugins" menu item should be available to is_staff user regardless of HIDE_RESTRICTED_UI."""
+    def test_installed_apps_visible_to_staff_with_hide_restricted_ui_false(self):
+        """The "Installed Apps" menu item should be available to is_staff user regardless of HIDE_RESTRICTED_UI."""
         # Make user admin
         self.user.is_staff = True
         self.user.save()
@@ -217,30 +214,28 @@ class NavRestrictedUI(TestCase):
         self.assertInHTML(
             f"""
             <li>
-              <div class="buttons pull-right"></div>
-              <a href="{self.url}" data-item-weight="{self.item_weight}">Installed Plugins</a>
+              <a href="{self.url}" data-item-weight="{self.item_weight}">Installed Apps</a>
             </li>
             """,
             response_content,
         )
 
     @override_settings(HIDE_RESTRICTED_UI=True)
-    def test_installed_plugins_not_visible_to_non_staff_user_with_hide_restricted_ui_true(self):
-        """The "Installed Plugins" menu item should be hidden from a non-staff user when HIDE_RESTRICTED_UI=True."""
+    def test_installed_apps_not_visible_to_non_staff_user_with_hide_restricted_ui_true(self):
+        """The "Installed Apps" menu item should be hidden from a non-staff user when HIDE_RESTRICTED_UI=True."""
         response_content = self.make_request()
 
-        self.assertNotRegex(response_content, r"Installed\s+Plugins")
+        self.assertNotRegex(response_content, r"Installed\s+Apps")
 
     @override_settings(HIDE_RESTRICTED_UI=False)
-    def test_installed_plugins_disabled_to_non_staff_user_with_hide_restricted_ui_false(self):
-        """The "Installed Plugins" menu item should be disabled for a non-staff user when HIDE_RESTRICTED_UI=False."""
+    def test_installed_apps_disabled_to_non_staff_user_with_hide_restricted_ui_false(self):
+        """The "Installed Apps" menu item should be disabled for a non-staff user when HIDE_RESTRICTED_UI=False."""
         response_content = self.make_request()
 
         self.assertInHTML(
             f"""
             <li class="disabled">
-              <div class="buttons pull-right"></div>
-              <a href="{self.url}" data-item-weight="{self.item_weight}">Installed Plugins</a>
+              <a href="{self.url}" data-item-weight="{self.item_weight}">Installed Apps</a>
             </li>
             """,
             response_content,

nautobot/core/tests/test_views_utils.py

@@ -7,11 +7,8 @@ from nautobot.dcim.models import DeviceRedundancyGroup
 
 
 class CheckFilterForDisplayTest(TestCase):
-    """
-    Validate the operation of check_filter_for_display().
-    """
-
     def test_check_filter_for_display(self):
+        """Validate the operation of check_filter_for_display()."""
 
         device_filter_set_filters = DeviceFilterSet().get_filters()
 
@@ -42,7 +39,7 @@ class CheckFilterForDisplayTest(TestCase):
         with self.subTest("Test get field label, none exists (fallback)"):
             expected_output = {
                 "name": "id",
-                "display": "id",
+                "display": "Id",
                 "values": [{"name": "example_field_value", "display": "example_field_value"}],
             }
 
@@ -68,7 +65,7 @@ class CheckFilterForDisplayTest(TestCase):
             example_obj = DeviceRedundancyGroup.objects.first()
             expected_output = {
                 "name": "device_redundancy_group",
-                "display": "Device Redundancy Groups (slug or ID)",
+                "display": "Device Redundancy Groups (name or ID)",
                 "values": [{"name": str(example_obj.pk), "display": str(example_obj)}],
             }
 
@@ -98,6 +95,6 @@ class CheckFilterForDisplayTest(TestCase):
         #         "values": [{"name": "fake_slug", "display": "fake_slug"}],
         #     }
 
-        #     self.assertEqual(
-        #         check_filter_for_display(device_filter_set_filters, "manufacturer", ["fake_slug"]), expected_output
-        #     )
+        # with self.assertEqual(
+        #     check_filter_for_display(device_filter_set_filters, "manufacturer", ["fake_slug"]), expected_output
+        # )