nautobot 2.0.5__py3-none-any.whl → 2.1.0b1__py3-none-any.whl

nautobot/core/tests/integration/test_navbar.py

@@ -1,5 +1,3 @@
-from django.test.utils import override_settings
-
 from nautobot.core.testing.integration import SeleniumTestCase
 
 
@@ -10,19 +8,19 @@ class NavBarTestCase(SeleniumTestCase):
     navbar = {
         "Organization": {
             "Locations": {
-                "Location": {
+                "Locations": {
                     "permission": "dcim.view_location",
-                    "buttons": ["Add", "Import"],
+                    "buttons": ["Add"],
                 },
                 "Location Types": {
                     "permission": "dcim.view_locationtype",
-                    "buttons": ["Add", "Import"],
+                    "buttons": ["Add"],
                 },
             },
             "Tags": {
                 "Tags": {
                     "permission": "extras.view_tag",
-                    "buttons": ["Add", "Import"],
+                    "buttons": ["Add"],
                 },
             },
         },
@@ -46,7 +44,6 @@ class NavBarTestCase(SeleniumTestCase):
         self.logout()
         super().tearDown()
 
-    @override_settings(HIDE_RESTRICTED_UI=False)
     def test_navbar_render_superuser(self):
         """
         Render navbar from home page with superuser.
@@ -60,75 +57,24 @@ class NavBarTestCase(SeleniumTestCase):
 
         for tab_name, groups in self.navbar.items():
             # XPath to find tabs using the tab name
-            tab_xpath = f"//*[@id='navbar']//*[contains(text(), '{tab_name}')]"
+            tab_xpath = f"//*[@id='navbar']//*[normalize-space()='{tab_name}']"
             tab = self.browser.find_by_xpath(tab_xpath)
             tab.click()
             self.assertTrue(bool(tab["aria-expanded"]))
 
             for group_name, items in groups.items():
                 # Append onto tab xpath with group name search
-                group = tab.find_by_xpath(f"{tab_xpath}/following-sibling::ul//li[contains(text(), '{group_name}')]")
+                group = tab.find_by_xpath(f"{tab_xpath}/following-sibling::ul//li[normalize-space()='{group_name}']")
 
                 for item_name in items:
-                    item_xpath = f"{tab_xpath}/following-sibling::ul//li[.//a[contains(text(), '{item_name}')]]"
+                    item_xpath = f"{tab_xpath}/following-sibling::ul//li[.//a[normalize-space()='{item_name}']]"
                     group.find_by_xpath(item_xpath)
 
-    @override_settings(HIDE_RESTRICTED_UI=False)
-    def test_navbar_render_limit_permissions(self):
-        """
-        Render navbar from home page with limited permissions.
-        """
-        self.add_permissions("extras.view_relationship")
-        user_permissions = self.user.get_all_permissions()
-
-        self.browser.visit(self.live_server_url)
-
-        for tab_name, groups in self.navbar.items():
-            # XPath to find tabs using the tab name
-            tab_xpath = f"//*[@id='navbar']//*[contains(text(), '{tab_name}')]"
-            tab = self.browser.find_by_xpath(tab_xpath)
-            tab.click()
-            self.assertTrue(bool(tab["aria-expanded"]))
-
-            for group_name, items in groups.items():
-                # Append onto tab xpath with group name search
-                group = tab.find_by_xpath(f"{tab_xpath}/following-sibling::ul//li[contains(text(), '{group_name}')]")
-
-                for item_name, item_details in items.items():
-                    item_xpath = f"{tab_xpath}/following-sibling::ul//li[.//a[contains(text(), '{item_name}')]]"
-                    item = group.find_by_xpath(item_xpath)
-                    if item_details["permission"] in user_permissions:
-                        self.assertNotEqual(item["class"], "disabled", f"Item `{item_name}` should not be disabled.")
-                    else:
-                        self.assertEqual(item["class"], "disabled", f"Item `{item_name}` should be disabled.")
-
-    @override_settings(HIDE_RESTRICTED_UI=False)
-    def test_navbar_render_no_permissions(self):
-        """
-        Render navbar from home page with no permissions.
-        """
-        self.browser.visit(self.live_server_url)
-
-        for tab_name, groups in self.navbar.items():
-            # XPath to find tabs using the tab name
-            tab_xpath = f"//*[@id='navbar']//*[contains(text(), '{tab_name}')]"
-            tab = self.browser.find_by_xpath(tab_xpath)
             tab.click()
-            self.assertTrue(bool(tab["aria-expanded"]))
-
-            for group_name, items in groups.items():
-                # Append onto tab xpath with group name search
-                group = tab.find_by_xpath(f"{tab_xpath}/following-sibling::ul//li[contains(text(), '{group_name}')]")
-
-                for item_name in items:
-                    item_xpath = f"{tab_xpath}/following-sibling::ul//li[.//a[contains(text(), '{item_name}')]]"
-                    item = group.find_by_xpath(item_xpath)
-                    self.assertEqual(item["class"], "disabled", f"Item `{item_name}` should be disabled.")
 
-    @override_settings(HIDE_RESTRICTED_UI=True)
-    def test_navbar_render_restricted_ui(self):
+    def test_navbar_render_with_limited_permissions(self):
         """
-        Render navbar from home page with restricted UI set to True.
+        Render navbar from home page with limited permissions.
         This restricts the user to be able to view ONLY relationships on the navbar.
         It then checks the UI for these restrictions.
         """
@@ -146,7 +92,7 @@ class NavBarTestCase(SeleniumTestCase):
                         tab_flag = True
 
             # XPath to find tabs using the tab name
-            tabs = self.browser.find_by_xpath(f"//*[@id='navbar']//*[contains(text(), '{tab_name}')]")
+            tabs = self.browser.find_by_xpath(f"//*[@id='navbar']//*[normalize-space()='{tab_name}']")
             if tab_flag:
                 self.assertEqual(len(tabs), 1)
             else:

nautobot/core/tests/integration/test_plugin_home.py

@@ -1,4 +1,3 @@
-from django.test.utils import override_settings
 from django.conf import settings
 from unittest import skipIf
 
@@ -89,7 +88,6 @@ class PluginHomeTestCase(SeleniumTestCase):
                 counter_html = int(item_html.find_by_xpath("./../../span")["innerHTML"])
                 self.assertEqual(counter, counter_html)
 
-    @override_settings(HIDE_RESTRICTED_UI=False)
     def test_homepage_render_no_permissions(self):
         """
         Render homepage with no permissions.
@@ -101,7 +99,8 @@ class PluginHomeTestCase(SeleniumTestCase):
             columns_html.first.find_by_xpath(f".//strong[text()='{panel_name}']")
             for item_name, _ in panel_details.items():
                 item_html = columns_html.first.find_by_xpath(f".//h4[contains(text(), '{item_name}')]")
-                self.assertTrue("mdi mdi-lock" in item_html.find_by_xpath("./../span")["innerHTML"])
+                # Assert Panel items without permissions are not shown in DOM
+                self.assertFalse(item_html)
 
     def test_examplemodel_custom_panel(self):
         """
@@ -118,7 +117,6 @@ class PluginHomeTestCase(SeleniumTestCase):
         for item_name in self.custom_panel_examplemodel["items"]:
             columns_html.first.find_by_xpath(f".//a[contains(text(), '{item_name}')]")
 
-    @override_settings(HIDE_RESTRICTED_UI=False)
     def test_homepage_render_limit_permissions(self):
         """
         Render homepage with limited permissions.
@@ -142,4 +140,5 @@ class PluginHomeTestCase(SeleniumTestCase):
                         self.assertEqual(counter, counter_html)
                 else:
                     item_html = columns_html.first.find_by_xpath(f".//h4[contains(text(), '{item_name}')]")
-                    self.assertTrue("mdi mdi-lock" in item_html.find_by_xpath("./../span")["innerHTML"])
+                    # Assert Layout items without permission is not visible in DOM
+                    self.assertFalse(item_html)

nautobot/core/tests/integration/test_plugin_navbar.py

@@ -19,7 +19,7 @@ class PluginNavBarTestCase(SeleniumTestCase):
             "Example Group 1": {
                 "Example Model": {
                     "permission": "example_plugin.view_examplemodel",
-                    "buttons": ["Add", "Import"],
+                    "buttons": ["Add"],
                 },
             },
         },
@@ -27,23 +27,23 @@ class PluginNavBarTestCase(SeleniumTestCase):
             "Circuits": {
                 "Circuits": {
                     "permission": "circuits.view_circuit",
-                    "buttons": ["Add", "Import"],
+                    "buttons": ["Add"],
                 },
-                "Circuit Type": {
+                "Circuit Types": {
                     "permission": "circuits.view_circuittype",
-                    "buttons": ["Add", "Import"],
+                    "buttons": ["Add"],
                 },
             },
             "Example Circuit Group": {
                 "Example Model": {
                     "permission": "example_plugin.view_examplemodel",
-                    "buttons": ["Add", "Import"],
+                    "buttons": ["Add"],
                 },
             },
             "Providers": {
                 "Providers": {
                     "permission": "circuits.view_provider",
-                    "buttons": ["Add", "Import"],
+                    "buttons": ["Add"],
                 },
             },
         },
@@ -51,7 +51,7 @@ class PluginNavBarTestCase(SeleniumTestCase):
             "Example Nautobot App": {
                 "Models": {
                     "permission": "example_plugin.view_examplemodel",
-                    "buttons": ["Add a new example model", "Import example models"],
+                    "buttons": ["Add a new example model"],
                 },
                 "Other Models": {
                     "permission": "example_plugin.view_examplemodel",
@@ -80,14 +80,14 @@ class PluginNavBarTestCase(SeleniumTestCase):
         # Retrieve home page
         self.browser.visit(self.live_server_url)
 
-        tab_xpath = "//*[@id='navbar']//*[contains(text(), 'Example Menu')]"
+        tab_xpath = "//*[@id='navbar']//*[normalize-space()='Example Menu']"
         tab = self.browser.find_by_xpath(tab_xpath)
         tab.click()
         self.assertTrue(bool(tab["aria-expanded"]))
 
-        group = tab.find_by_xpath(f"{tab_xpath}/following-sibling::ul//li[contains(text(), 'Example Group 1')]")
+        group = tab.find_by_xpath(f"{tab_xpath}/following-sibling::ul//li[normalize-space()='Example Group 1']")
 
-        item_xpath = f"{tab_xpath}/following-sibling::ul//li[.//a[contains(text(), 'Example Model')]]"
+        item_xpath = f"{tab_xpath}/following-sibling::ul//li[.//a[normalize-space()='Example Model']]"
         group.find_by_xpath(item_xpath)
 
     def test_plugin_navbar_modify_circuits(self):
@@ -101,15 +101,15 @@ class PluginNavBarTestCase(SeleniumTestCase):
         # Retrieve home page
         self.browser.visit(self.live_server_url)
 
-        tab_xpath = "//*[@id='navbar']//*[contains(text(), 'Circuits')]"
+        tab_xpath = "//*[@id='navbar']//*[normalize-space()='Circuits']"
         tab = self.browser.find_by_xpath(tab_xpath)
         tab.click()
         self.assertTrue(bool(tab["aria-expanded"]))
 
         for group_name, items in self.navbar["Circuits"].items():
-            group = tab.find_by_xpath(f"{tab_xpath}/following-sibling::ul//li[contains(text(), '{group_name}')]")
+            group = tab.find_by_xpath(f"{tab_xpath}/following-sibling::ul//li[normalize-space()='{group_name}']")
             for item_name, item_details in items.items():
-                item_xpath = f"{tab_xpath}/following-sibling::ul//li[.//a[contains(text(), '{item_name}')]]"
+                item_xpath = f"{tab_xpath}/following-sibling::ul//li[.//a[normalize-space()='{item_name}']]"
                 item = group.find_by_xpath(item_xpath)
 
                 for button_name in item_details["buttons"]:
@@ -120,6 +120,8 @@ class PluginNavBarTestCase(SeleniumTestCase):
                         icon = button.find_by_xpath(f"{item_xpath}/div//a[@title='{button_name}']/i")
                         self.assertIn(button_icon, icon["class"])
 
+        tab.click()
+
     def test_plugin_navbar_plugin_tab(self):
         """
         Test that old-style plugin menu definitions are correctly rendered to the Plugins menu tab.
@@ -131,15 +133,15 @@ class PluginNavBarTestCase(SeleniumTestCase):
         # Retrieve home page
         self.browser.visit(self.live_server_url)
 
-        tab_xpath = "//*[@id='navbar']//*[contains(text(), 'Plugins')]"
+        tab_xpath = "//*[@id='navbar']//*[normalize-space()='Plugins']"
         tab = self.browser.find_by_xpath(tab_xpath)
         tab.click()
         self.assertTrue(bool(tab["aria-expanded"]))
 
         for group_name, items in self.navbar["Plugins"].items():
-            group = tab.find_by_xpath(f"{tab_xpath}/following-sibling::ul//li[contains(text(), '{group_name}')]")
+            group = tab.find_by_xpath(f"{tab_xpath}/following-sibling::ul//li[normalize-space()='{group_name}']")
             for item_name, item_details in items.items():
-                item_xpath = f"{tab_xpath}/following-sibling::ul//li[.//a[contains(text(), '{item_name}')]]"
+                item_xpath = f"{tab_xpath}/following-sibling::ul//li[.//a[normalize-space()='{item_name}']]"
                 item = group.find_by_xpath(item_xpath)
 
                 for button_name in item_details["buttons"]:
@@ -149,3 +151,5 @@ class PluginNavBarTestCase(SeleniumTestCase):
                     if button_icon := getattr(ButtonActionIconChoices, button_name.upper(), None):
                         icon = button.find_by_xpath(f"{item_xpath}/div//a[@title='{button_name}']/i")
                         self.assertIn(button_icon, icon["class"])
+
+        tab.click()

nautobot/core/tests/integration/test_theme.py

@@ -4,6 +4,10 @@ from nautobot.core.testing.integration import SeleniumTestCase
 class ThemeTestCase(SeleniumTestCase):
     """Integration test to check theme selection modal functionality."""
 
+    def setUp(self):
+        super().setUp()
+        self.login(self.user.username, self.password)
+
     def test_modal_not_rendered(self):
         """As implemented, modal dialog box does not render until activated."""
 

nautobot/core/tests/test_api.py

@@ -1,4 +1,3 @@
-from copy import deepcopy
 import csv
 from io import BytesIO, StringIO
 import json
@@ -6,6 +5,7 @@ from unittest import skip
 
 from django.contrib.contenttypes.models import ContentType
 from django.conf import settings
+from django.contrib.auth import get_user_model
 from django.test import RequestFactory, override_settings, TestCase
 from django.urls import reverse
 
@@ -29,6 +29,9 @@ from nautobot.ipam import models as ipam_models
 from nautobot.ipam.api import serializers as ipam_serializers
 
 
+User = get_user_model()
+
+
 class AppTest(testing.APITestCase):
     def test_root(self):
         url = reverse("api-root")
@@ -73,6 +76,9 @@ class APIDocsTestCase(TestCase):
         self.cf_text.save()
 
     def test_api_docs(self):
+        user = User.objects.create_user(username="nautobotuser")
+        self.client.force_login(user)
+
         url = reverse("api_docs")
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200)
@@ -183,17 +189,6 @@ class APIVersioningTestCase(testing.APITestCase):
     Testing our custom API versioning, NautobotAPIVersioning.
     """
 
-    OVERRIDE_REST_FRAMEWORK = deepcopy(settings.REST_FRAMEWORK)
-    # For Nautobot 2.0, the default/only supported API version is 2.0, which limits our ability to test with multiple
-    # or min/max versions. For test purposes we force there to be some extra versions available.
-    EXTRA_ALLOWED_VERSIONS = [
-        f"{settings.VERSION_MAJOR - 1}.99",
-        *settings.REST_FRAMEWORK["ALLOWED_VERSIONS"],
-        f"{settings.VERSION_MAJOR}.{settings.VERSION_MINOR + 1}",
-    ]
-    OVERRIDE_REST_FRAMEWORK["ALLOWED_VERSIONS"] = EXTRA_ALLOWED_VERSIONS
-    OVERRIDE_REST_FRAMEWORK["DEFAULT_VERSION"] = EXTRA_ALLOWED_VERSIONS[-1]
-
     def test_default_version(self):
         """Test that a request with no specific API version gets the default version, which is the current version."""
         url = reverse("api-root")
@@ -203,13 +198,6 @@ class APIVersioningTestCase(testing.APITestCase):
         self.assertEqual(response["API-Version"], api_settings.DEFAULT_VERSION)
         self.assertEqual(response["API-Version"], f"{settings.VERSION_MAJOR}.{settings.VERSION_MINOR}")
 
-        with override_settings(REST_FRAMEWORK=self.OVERRIDE_REST_FRAMEWORK):
-            response = self.client.get(url, **self.header)
-            self.assertHttpStatus(response, 200)
-            self.assertIn("API-Version", response)
-            self.assertEqual(response["API-Version"], self.OVERRIDE_REST_FRAMEWORK["DEFAULT_VERSION"])
-            self.assertEqual(response["API-Version"], f"{settings.VERSION_MAJOR}.{settings.VERSION_MINOR + 1}")
-
     def test_allowed_versions(self):
         """Test that all expected versions are supported."""
         for minor_version in range(0, settings.VERSION_MINOR + 1):
@@ -237,7 +225,7 @@ class APIVersioningTestCase(testing.APITestCase):
         self.assertEqual(response["API-Version"], default_version)
 
         max_version = api_settings.ALLOWED_VERSIONS[-1]
-        self.set_api_version(min_version)
+        self.set_api_version(max_version)
         response = self.client.get(url, **self.header)
         self.assertHttpStatus(response, 200)
         self.assertIn("API-Version", response)
@@ -250,29 +238,6 @@ class APIVersioningTestCase(testing.APITestCase):
         for version in api_settings.ALLOWED_VERSIONS:
             self.assertIn(version, response.data["detail"])
 
-        # Also test with explicitly added additional allowed versions
-        with override_settings(REST_FRAMEWORK=self.OVERRIDE_REST_FRAMEWORK):
-            min_version = self.EXTRA_ALLOWED_VERSIONS[0]
-            self.set_api_version(min_version)
-            response = self.client.get(url, **self.header)
-            self.assertHttpStatus(response, 200)
-            self.assertIn("API-Version", response)
-            self.assertEqual(response["API-Version"], min_version)
-
-            max_version = self.EXTRA_ALLOWED_VERSIONS[-1]
-            self.set_api_version(max_version)
-            response = self.client.get(url, **self.header)
-            self.assertHttpStatus(response, 200)
-            self.assertIn("API-Version", response)
-            self.assertEqual(response["API-Version"], max_version)
-
-            invalid_version = "0.0"
-            self.set_api_version(invalid_version)
-            response = self.client.get(url, **self.header)
-            self.assertHttpStatus(response, 406)  # Not Acceptable
-            for version in self.EXTRA_ALLOWED_VERSIONS:
-                self.assertIn(version, response.data["detail"])
-
     def test_query_version(self):
         """Test that the API version can be specified via a query parameter."""
         url = reverse("api-root")
@@ -301,33 +266,12 @@ class APIVersioningTestCase(testing.APITestCase):
         for version in api_settings.ALLOWED_VERSIONS:
             self.assertIn(version, response.data["detail"])
 
-        # Also test with explicitly added additional allowed versions
-        with override_settings(REST_FRAMEWORK=self.OVERRIDE_REST_FRAMEWORK):
-            min_version = self.EXTRA_ALLOWED_VERSIONS[0]
-            response = self.client.get(f"{url}?api_version={min_version}", **self.header)
-            self.assertHttpStatus(response, 200)
-            self.assertIn("API-Version", response)
-            self.assertEqual(response["API-Version"], min_version)
-
-            max_version = self.EXTRA_ALLOWED_VERSIONS[-1]
-            response = self.client.get(f"{url}?api_version={max_version}", **self.header)
-            self.assertHttpStatus(response, 200)
-            self.assertIn("API-Version", response)
-            self.assertEqual(response["API-Version"], max_version)
-
-            invalid_version = "0.0"
-            response = self.client.get(f"{url}?api_version={invalid_version}", **self.header)
-            self.assertHttpStatus(response, 404)
-            for version in self.EXTRA_ALLOWED_VERSIONS:
-                self.assertIn(version, response.data["detail"])
-
-    @override_settings(REST_FRAMEWORK=OVERRIDE_REST_FRAMEWORK)
     def test_header_and_query_version(self):
         """Test the behavior when the API version is specified in both the Accept header *and* a query parameter."""
         url = reverse("api-root")
 
-        min_version = self.EXTRA_ALLOWED_VERSIONS[0]
-        max_version = self.EXTRA_ALLOWED_VERSIONS[-1]
+        min_version = api_settings.ALLOWED_VERSIONS[0]
+        max_version = api_settings.ALLOWED_VERSIONS[-1]
         # Specify same version both as Accept header and as query parameter (valid)
         self.set_api_version(max_version)
         response = self.client.get(f"{url}?api_version={max_version}", **self.header)
@@ -873,6 +817,9 @@ class APIOrderingTestCase(testing.APITestCase):
 class NewUIGetMenuAPIViewTestCase(testing.APITestCase):
     def test_get_menu(self):
         """Asset response from new ui nav menu api returns a well formatted registry["new_ui_nav_menu"] expected by nautobot-ui."""
+        self.user.is_superuser = True
+        self.user.save()
+
         url = reverse("ui-api:get-menu")
         response = self.client.get(url, **self.header)
         expected_response = {
@@ -975,6 +922,7 @@ class NewUIGetMenuAPIViewTestCase(testing.APITestCase):
                 },
             },
         }
+
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.data, expected_response)
 

nautobot/core/tests/test_filters.py

@@ -1,3 +1,5 @@
+import datetime
+
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
@@ -9,6 +11,8 @@ from django.test.utils import isolate_apps
 import django_filters
 from tree_queries.models import TreeNodeForeignKey
 
+from nautobot.circuits.filters import CircuitFilterSet
+from nautobot.circuits.models import Circuit, CircuitType, Provider
 from nautobot.core import filters, testing
 from nautobot.core.models import fields as core_fields
 from nautobot.core.utils import lookup
@@ -1450,6 +1454,129 @@ class SearchFilterTest(TestCase, testing.NautobotTestCaseMixin):
                 q = filters.SearchFilter(filter_predicates={"asn": ["icontains"]})
 
 
+class LookupIsNullTest(TestCase, testing.NautobotTestCaseMixin):
+    """
+    Validate isnull is properly applied and filtering.
+    """
+
+    platform_queryset = dcim_models.Platform.objects.all()
+    platform_filterset = dcim_filters.PlatformFilterSet
+    circuit_queryset = Circuit.objects.all()
+    circuit_filterset = CircuitFilterSet
+    device_queryset = dcim_models.Device.objects.all()
+    device_filterset = dcim_filters.DeviceFilterSet
+
+    @classmethod
+    def setUpTestData(cls):
+        location_type = dcim_models.LocationType.objects.create(name="Location Type 1")
+        location_status = extras_models.Status.objects.get_for_model(dcim_models.Location).first()
+        location = dcim_models.Location.objects.create(
+            name="Location 1",
+            location_type=location_type,
+            status=location_status,
+        )
+        manufacturer = dcim_models.Manufacturer.objects.create(name="Manufacturer 1")
+        dcim_models.Platform.objects.create(name="Platform 1")
+        platform = dcim_models.Platform.objects.create(name="Platform 2", manufacturer=manufacturer)
+
+        device_type = dcim_models.DeviceType.objects.create(
+            manufacturer=manufacturer,
+            model="Model 1",
+            is_full_depth=True,
+        )
+        device_role = extras_models.Role.objects.create(name="Active Test")
+        device_role.content_types.add(ContentType.objects.get_for_model(dcim_models.Device))
+
+        device_status = extras_models.Status.objects.get_for_model(dcim_models.Device).first()
+
+        dcim_models.Device.objects.create(
+            name="Device 1",
+            device_type=device_type,
+            role=device_role,
+            platform=platform,
+            location=location,
+            status=device_status,
+        )
+        dcim_models.Device.objects.create(
+            device_type=device_type,
+            role=device_role,
+            platform=platform,
+            location=location,
+            status=device_status,
+        )
+
+        provider = Provider.objects.create(name="provider 1", asn=1)
+        circuit_type = CircuitType.objects.create(name="Circuit Type 1")
+        circuit_status = extras_models.Status.objects.get_for_model(dcim_models.Location).first()
+
+        Circuit.objects.create(
+            cid="Circuit 1",
+            provider=provider,
+            install_date=datetime.date(2020, 1, 1),
+            commit_rate=1000,
+            circuit_type=circuit_type,
+            status=circuit_status,
+        )
+        Circuit.objects.create(
+            cid="Circuit 2",
+            provider=provider,
+            circuit_type=circuit_type,
+            status=circuit_status,
+        )
+
+    def test_isnull_on_fk(self):
+        """Test that the `isnull` filter is applied for True and False queries on foreign key fields."""
+        params = {"manufacturer__isnull": True}
+        self.assertQuerysetEqualAndNotEmpty(
+            dcim_filters.PlatformFilterSet(params, self.platform_queryset).qs,
+            dcim_models.Platform.objects.filter(manufacturer__isnull=True),
+        )
+        params = {"manufacturer__isnull": False}
+        self.assertQuerysetEqualAndNotEmpty(
+            dcim_filters.PlatformFilterSet(params, self.platform_queryset).qs,
+            dcim_models.Platform.objects.filter(manufacturer__isnull=False),
+        )
+
+    def test_isnull_on_integer(self):
+        """Test that the `isnull` filter is applied for True and False queries on integer fields."""
+        params = {"commit_rate__isnull": True}
+        self.assertQuerysetEqualAndNotEmpty(
+            CircuitFilterSet(params, self.circuit_queryset).qs,
+            Circuit.objects.filter(commit_rate__isnull=True),
+        )
+        params = {"commit_rate__isnull": False}
+        self.assertQuerysetEqualAndNotEmpty(
+            CircuitFilterSet(params, self.circuit_queryset).qs,
+            Circuit.objects.filter(commit_rate__isnull=False),
+        )
+
+    def test_isnull_on_date(self):
+        """Test that the `isnull` filter is applied for True and False queries on datetime fields."""
+        params = {"install_date__isnull": True}
+        self.assertQuerysetEqualAndNotEmpty(
+            CircuitFilterSet(params, self.circuit_queryset).qs,
+            Circuit.objects.filter(install_date__isnull=True),
+        )
+        params = {"install_date__isnull": False}
+        self.assertQuerysetEqualAndNotEmpty(
+            CircuitFilterSet(params, self.circuit_queryset).qs,
+            Circuit.objects.filter(install_date__isnull=False),
+        )
+
+    def test_isnull_on_char(self):
+        """Test that the `isnull` filter is applied for True and False queries on char fields."""
+        params = {"name__isnull": True}
+        self.assertQuerysetEqualAndNotEmpty(
+            dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
+            dcim_models.Device.objects.filter(name__isnull=True),
+        )
+        params = {"name__isnull": False}
+        self.assertQuerysetEqualAndNotEmpty(
+            dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
+            dcim_models.Device.objects.filter(name__isnull=False),
+        )
+
+
 class FilterTypeTest(TestCase):
     client_class = testing.NautobotTestClient
 

nautobot/core/tests/test_forms.py

@@ -687,7 +687,7 @@ class DynamicFilterFormTest(TestCase):
                     ("racks", "Rack (name or ID)"),
                     ("rack_groups", "Rack groups (name or ID)"),
                     ("shipping_address", "Shipping address"),
-                    ("status", "Status"),
+                    ("status", "Status (name or ID)"),
                     ("vlans", "Tagged VLANs (VID or ID)"),
                     ("tags", "Tags"),
                     ("tenant_id", 'Tenant (ID) (deprecated, use "tenant" filter instead)'),