nautobot 2.4.1__py3-none-any.whl → 2.4.3__py3-none-any.whl

nautobot/extras/tests/test_models.py

@@ -1,5 +1,6 @@
 from datetime import datetime, timedelta, timezone
 import os
+import shutil
 import tempfile
 from unittest import expectedFailure, mock
 import uuid
@@ -17,6 +18,7 @@ from django.test import override_settings
 from django.test.utils import isolate_apps
 from django.utils.timezone import get_default_timezone, now
 from django_celery_beat.tzcrontab import TzAwareCrontab
+from git import GitCommandError
 from jinja2.exceptions import TemplateAssertionError, TemplateSyntaxError
 import time_machine
 
@@ -48,6 +50,7 @@ from nautobot.extras.constants import (
     JOB_LOG_MAX_LOG_OBJECT_LENGTH,
     JOB_OVERRIDABLE_FIELDS,
 )
+from nautobot.extras.datasources.registry import get_datasource_contents
 from nautobot.extras.jobs import get_job
 from nautobot.extras.models import (
     ComputedField,
@@ -83,6 +86,7 @@ from nautobot.extras.models import (
 from nautobot.extras.models.statuses import StatusModel
 from nautobot.extras.registry import registry
 from nautobot.extras.secrets.exceptions import SecretParametersError, SecretProviderError, SecretValueNotFoundError
+from nautobot.extras.tests.git_helper import create_and_populate_git_repository
 from nautobot.ipam.models import IPAddress
 from nautobot.tenancy.models import Tenant
 from nautobot.virtualization.models import (
@@ -1072,6 +1076,285 @@ class GitRepositoryTest(ModelTestCases.BaseModelTestCase):
         self.repo.remote_url = "http://some-private-host/example.git"
         self.repo.validated_save()
 
+    def test_clone_to_directory_context_manager(self):
+        """Confirm that the clone_to_directory_context() context manager method works as expected."""
+        try:
+            specified_path = tempfile.mkdtemp()
+            self.tempdir = tempfile.TemporaryDirectory()  # pylint: disable=consider-using-with
+            create_and_populate_git_repository(self.tempdir.name, divergent_branch="divergent-branch")
+            self.repo_slug = "new_git_repo"
+            self.repo = GitRepository(
+                name="New Git Repository",
+                slug=self.repo_slug,
+                remote_url="file://"
+                + self.tempdir.name,  # file:// URLs aren't permitted normally, but very useful here!
+                branch="main",
+                # Provide everything we know we can provide
+                provided_contents=[
+                    entry.content_identifier for entry in get_datasource_contents("extras.gitrepository")
+                ],
+            )
+            self.repo.save()
+            with self.subTest("Clone a repository with no path argument provided"):
+                with self.repo.clone_to_directory_context() as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(tempfile.gettempdir()))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema2.json"))
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with a path argument provided"):
+                with self.repo.clone_to_directory_context(path=specified_path) as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema2.json"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with the branch argument provided"):
+                with self.repo.clone_to_directory_context(path=specified_path, branch="main") as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema2.json"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with non-default branch provided"):
+                with self.repo.clone_to_directory_context(path=specified_path, branch="empty-repo") as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    # empty-repo should contain no files
+                    self.assertFalse(os.path.exists(path + "/config_context_schemas"))
+                    self.assertFalse(os.path.exists(path + "/config_contexts"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with divergent branch provided"):
+                with self.repo.clone_to_directory_context(path=specified_path, branch="divergent-branch") as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema2.json"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with the head argument provided"):
+                with self.repo.clone_to_directory_context(path=specified_path, head="valid-files") as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/schema-1.yaml"))
+                    self.assertTrue(os.path.exists(path + "/config_contexts/context.yaml"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with depth argument provided"):
+                with self.repo.clone_to_directory_context(path=specified_path, depth=1) as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                    self.assertTrue(os.path.exists(path + "/config_contexts/badcontext2.json"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a shallow repository with depth and valid head arguments provided"):
+                with self.repo.clone_to_directory_context(
+                    path=specified_path, depth=1, head="divergent-branch-tag"
+                ) as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                    self.assertTrue(os.path.exists(path + "/config_contexts/badcontext2.json"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a shallow repository with depth and invalid head arguments provided"):
+                with self.assertRaisesRegex(GitCommandError, "malformed object name valid-files"):
+                    # Shallow copy a repo should only have the latest commit
+                    with self.repo.clone_to_directory_context(path=specified_path, depth=1, head="valid-files") as path:
+                        pass
+
+            with self.subTest("Clone a shallow repository with depth and valid branch arguments provided"):
+                with self.repo.clone_to_directory_context(path=specified_path, depth=1, branch="main") as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                    self.assertTrue(os.path.exists(path + "/config_contexts/badcontext2.json"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a shallow repository with depth and divergent branch arguments provided"):
+                with self.repo.clone_to_directory_context(
+                    path=specified_path, depth=1, branch="divergent-branch"
+                ) as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                    self.assertTrue(os.path.exists(path + "/config_contexts/badcontext2.json"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Assert a GitCommandError is raised when an invalid commit hash is provided"):
+                with self.assertRaisesRegex(GitCommandError, "malformed object name non-existent"):
+                    with self.repo.clone_to_directory_context(path=specified_path, head="non-existent") as path:
+                        pass
+
+            with self.subTest("Assert a value error is raised when branch and head are both provided"):
+                with self.assertRaisesRegex(ValueError, "Cannot specify both branch and head"):
+                    with self.repo.clone_to_directory_context(branch="main", head="valid-files") as path:
+                        pass
+        finally:
+            shutil.rmtree(specified_path, ignore_errors=True)
+            shutil.rmtree(self.tempdir.name, ignore_errors=True)
+
+    def test_clone_to_directory_helper_methods(self):
+        """Confirm that the clone_to_directory()/cleanup_cloned_directory() methods work as expected."""
+        try:
+            specified_path = tempfile.mkdtemp()
+            self.tempdir = tempfile.TemporaryDirectory()  # pylint: disable=consider-using-with
+            create_and_populate_git_repository(self.tempdir.name, divergent_branch="divergent-branch")
+            self.repo_slug = "new_git_repo"
+            self.repo = GitRepository(
+                name="New Git Repository",
+                slug=self.repo_slug,
+                remote_url="file://"
+                + self.tempdir.name,  # file:// URLs aren't permitted normally, but very useful here!
+                branch="main",
+                # Provide everything we know we can provide
+                provided_contents=[
+                    entry.content_identifier for entry in get_datasource_contents("extras.gitrepository")
+                ],
+            )
+            self.repo.save()
+            with self.subTest("Clone a repository with no path argument provided"):
+                path = self.repo.clone_to_directory()
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(tempfile.gettempdir()))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema2.json"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with a path argument provided"):
+                path = self.repo.clone_to_directory(path=specified_path)
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema2.json"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with the branch argument provided"):
+                path = self.repo.clone_to_directory(path=specified_path, branch="main")
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema2.json"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with non-default branch provided"):
+                path = self.repo.clone_to_directory(path=specified_path, branch="empty-repo")
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertFalse(os.path.exists(path + "/config_context_schemas"))
+                self.assertFalse(os.path.exists(path + "/config_contexts"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with divergent branch provided"):
+                path = self.repo.clone_to_directory(path=specified_path, branch="divergent-branch")
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas"))
+                self.assertTrue(os.path.exists(path + "/config_contexts"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with the head argument provided"):
+                path = self.repo.clone_to_directory(path=specified_path, head="valid-files")
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/schema-1.yaml"))
+                self.assertTrue(os.path.exists(path + "/config_contexts/context.yaml"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with depth argument provided"):
+                path = self.repo.clone_to_directory(path=specified_path, depth=1)
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                self.assertTrue(os.path.exists(path + "/config_contexts/badcontext2.json"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a shallow repository with depth and valid head arguments provided"):
+                path = self.repo.clone_to_directory(path=specified_path, depth=1, head="divergent-branch-tag")
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                self.assertTrue(os.path.exists(path + "/config_contexts/badcontext2.json"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a shallow repository with depth and invalid head arguments provided"):
+                with self.assertRaisesRegex(GitCommandError, "malformed object name valid-files"):
+                    # Shallow copy a repo should only have the latest commit
+                    path = self.repo.clone_to_directory(path=specified_path, depth=1, head="valid-files")
+                    self.repo.cleanup_cloned_directory(path)
+                    self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a shallow repository with depth and valid branch arguments provided"):
+                path = self.repo.clone_to_directory(path=specified_path, depth=1, branch="main")
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                self.assertTrue(os.path.exists(path + "/config_contexts/badcontext2.json"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a shallow repository with depth and divergent branch arguments provided"):
+                path = self.repo.clone_to_directory(path=specified_path, depth=1, branch="divergent-branch")
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                self.assertTrue(os.path.exists(path + "/config_contexts/badcontext2.json"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Assert a GitCommandError is raised when an invalid commit hash is provided"):
+                with self.assertRaisesRegex(GitCommandError, "malformed object name non-existent"):
+                    path = self.repo.clone_to_directory(path=specified_path, head="non-existent")
+
+            with self.subTest("Assert a ValuError is raised when branch and head are both provided"):
+                with self.assertRaisesRegex(ValueError, "Cannot specify both branch and head"):
+                    path = self.repo.clone_to_directory(branch="main", head="valid-files")
+        finally:
+            shutil.rmtree(specified_path, ignore_errors=True)
+            shutil.rmtree(self.tempdir.name, ignore_errors=True)
+
 
 class JobModelTest(ModelTestCases.BaseModelTestCase):
     """

nautobot/extras/tests/test_utils.py

@@ -4,13 +4,34 @@ import uuid
 from django.core.cache import cache
 
 from nautobot.core.testing import TestCase
+from nautobot.dcim.models import Device, LocationType
 from nautobot.extras.choices import JobQueueTypeChoices
 from nautobot.extras.models import JobQueue
 from nautobot.extras.registry import registry
-from nautobot.extras.utils import get_celery_queues, get_worker_count, populate_model_features_registry
+from nautobot.extras.utils import (
+    get_base_template,
+    get_celery_queues,
+    get_worker_count,
+    populate_model_features_registry,
+)
+from nautobot.users.models import Token
 
 
 class UtilsTestCase(TestCase):
+    def test_get_base_template(self):
+        with self.subTest("explicitly specified base_template always wins"):
+            self.assertEqual(get_base_template("dcim/device/base.html", Device), "dcim/device/base.html")
+
+        with self.subTest("<model>.html wins over <model>_retrieve.html"):
+            # TODO: why do we even have both locationtype.html and locationtype_retrieve.html?
+            self.assertEqual(get_base_template(None, LocationType), "dcim/locationtype.html")
+
+        with self.subTest("<model>_retrieve.html is used if present"):
+            self.assertEqual(get_base_template(None, JobQueue), "extras/jobqueue_retrieve.html")
+
+        with self.subTest("generic/object_retrieve.html is used as a fallback"):
+            self.assertEqual(get_base_template(None, Token), "generic/object_retrieve.html")
+
     @mock.patch("celery.app.control.Inspect.active_queues")
     def test_get_celery_queues(self, mock_active_queues):
         with self.subTest("No queues"):

nautobot/extras/tests/test_views.py

@@ -820,7 +820,8 @@ class DynamicGroupTestCase(
         return super()._get_queryset().filter(group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_FILTER)  # TODO
 
     def test_get_object_with_permission(self):
-        instance = self._get_queryset().first()
+        location_ct = ContentType.objects.get_for_model(Location)
+        instance = self._get_queryset().exclude(content_type=location_ct).first()
         # Add view permissions for the group's members:
         self.add_permissions(get_permission_for_model(instance.content_type.model_class(), "view"))
 
@@ -831,6 +832,18 @@ class DynamicGroupTestCase(
         for member in instance.members:
             self.assertIn(str(member.pk), response_body)
 
+        # Test accessing DynamicGroup detail view with a different content type, more specifically, TreeModel
+        # https://github.com/nautobot/nautobot/issues/6806
+        tree_model_dg = DynamicGroup.objects.create(name="DG 4", content_type=location_ct)
+        # Add view permissions for the group's members:
+        self.add_permissions(get_permission_for_model(tree_model_dg.content_type.model_class(), "view"))
+        response = self.client.get(tree_model_dg.get_absolute_url())
+        self.assertHttpStatus(response, 200)
+        response_body = extract_page_body(response.content.decode(response.charset))
+        # Check that the "members" table in the detail view includes all appropriate member objects
+        for member in tree_model_dg.members:
+            self.assertIn(str(member.pk), response_body)
+
     def test_get_object_with_constrained_permission(self):
         instance = self._get_queryset().first()
         # Add view permission for one of the group's members but not the others:
@@ -1306,19 +1319,18 @@ class SavedViewTest(ModelViewTestCase):
 
     model = SavedView
 
-    def get_view_url_for_saved_view(self, saved_view, action="detail"):
+    def get_view_url_for_saved_view(self, saved_view=None, action="detail"):
         """
         Since saved view detail url redirects, we need to manually construct its detail url
         to test the content of its response.
         """
-        view = saved_view.view
-        pk = saved_view.pk
+        url = ""
 
-        if action == "detail":
-            url = reverse(view) + f"?saved_view={pk}"
-        elif action == "edit":
+        if action == "detail" and saved_view:
+            url = reverse(saved_view.view) + f"?saved_view={saved_view.pk}"
+        elif action == "edit" and saved_view:
             url = saved_view.get_absolute_url() + "update-config/"
-        else:
+        elif action == "create":
             url = reverse("extras:savedview_add")
 
         return url
@@ -1411,7 +1423,14 @@ class SavedViewTest(ModelViewTestCase):
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_update_saved_view_as_owner(self):
-        instance = self._get_queryset().first()
+        view_name = "dcim:location_list"
+        instance = SavedView.objects.create(
+            name="Location Saved View",
+            owner=self.user,
+            view=view_name,
+            is_global_default=True,
+        )
+
         update_query_strings = ["per_page=12", "&status=active", "&name=new_name_filter", "&sort=name"]
         update_url = self.get_view_url_for_saved_view(instance, "edit") + "?" + "".join(update_query_strings)
         # Try update the saved view with the same user as the owner of the saved view
@@ -1543,6 +1562,62 @@ class SavedViewTest(ModelViewTestCase):
         # Assert that Location List View got redirected to Saved View set as user default
         self.assertBodyContains(response, "<strong>User Location Default View</strong>", html=True)
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_filtered_view_precedes_global_default(self):
+        view_name = "dcim:location_list"
+        # Global saved view that will show Floor type locations only.
+        SavedView.objects.create(
+            name="Global Location Default View",
+            owner=self.user,
+            view=view_name,
+            is_global_default=True,
+            config={
+                "filter_params": {
+                    "location_type": ["Floor"],
+                }
+            },
+        )
+        response = self.client.get(reverse(view_name) + "?location_type=Campus", follow=True)
+        # Assert that the user is not redirected to the global default view
+        # But instead redirected to the filtered view
+        self.assertNotIn(
+            "<strong>Global Location Default View</strong>",
+            extract_page_body(response.content.decode(response.charset)),
+        )
+
+        # Floor type locations (Floor-<number>) should not be visible in the response
+        self.assertNotIn(
+            "Floor-",
+            extract_page_body(response.content.decode(response.charset)),
+        )
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_filtered_view_precedes_user_default(self):
+        view_name = "dcim:location_list"
+        # User saved view that will show Floor type locations only.
+        sv = SavedView.objects.create(
+            name="User Location Default View",
+            owner=self.user,
+            view=view_name,
+            config={
+                "filter_params": {
+                    "location_type": ["Floor"],
+                }
+            },
+        )
+        UserSavedViewAssociation.objects.create(user=self.user, saved_view=sv, view_name=sv.view)
+        response = self.client.get(reverse(view_name) + "?location_type=Campus", follow=True)
+        # Assert that the user is not redirected to the user default view
+        # But instead redirected to the filtered view
+        self.assertNotIn(
+            "<strong>User Location Default View</strong>", extract_page_body(response.content.decode(response.charset))
+        )
+        # Floor type locations (Floor-<number>) should not be visible in the response
+        self.assertNotIn(
+            "Floor-",
+            extract_page_body(response.content.decode(response.charset)),
+        )
+
     @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
     def test_is_shared(self):
         view_name = "dcim:location_list"
@@ -1568,6 +1643,119 @@ class SavedViewTest(ModelViewTestCase):
         self.assertIn(str(sv_shared.pk), response_body, msg=response_body)
         self.assertNotIn(str(sv_not_shared.pk), response_body, msg=response_body)
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_create_saved_views_contain_boolean_filter_params(self):
+        """
+        Test the entire Save View workflow from creating a Saved View to rendering the View with boolean filter parameters.
+        """
+        with self.subTest("Create job Saved View with boolean filter parameters"):
+            view_name = "extras:job_list"
+            app_label = view_name.split(":")[0]
+            model_name = view_name.split(":")[1].split("_")[0]
+            self.add_permissions(f"{app_label}.view_{model_name}")
+            create_query_strings = [
+                "&hidden=True",
+            ]
+            create_url = self.get_view_url_for_saved_view(action="create")
+            sv_name = "Hidden Jobs"
+            request = {
+                "path": create_url,
+                "data": post_data({"name": sv_name, "view": f"{view_name}", "params": "".join(create_query_strings)}),
+            }
+            self.assertHttpStatus(self.client.post(**request), 302)
+            instance = SavedView.objects.get(name=sv_name)
+            hidden_job = Job.objects.get(name="Example hidden job")
+            hidden_job.description = "I should not show in the UI!"
+            hidden_job.save()
+            self.assertEqual(instance.config["filter_params"]["hidden"], "True")
+            response = self.client.get(reverse(view_name) + "?saved_view=" + str(instance.pk), follow=True)
+            # Assert that Job List View rendered with the boolean filter parameter without error
+            self.assertHttpStatus(response, 200)
+            response_body = extract_page_body(response.content.decode(response.charset))
+            self.assertIn(str(instance.pk), response_body, msg=response_body)
+            self.assertBodyContains(response, f"<strong>{sv_name}</strong>", html=True)
+            # This is the description
+            self.assertBodyContains(response, "I should not show in the UI!", html=True)
+
+        with self.subTest("Create device Saved View with boolean filter parameters"):
+            view_name = "dcim:device_list"
+            app_label = view_name.split(":")[0]
+            model_name = view_name.split(":")[1].split("_")[0]
+            self.add_permissions(f"{app_label}.view_{model_name}")
+            create_query_strings = [
+                "&per_page=12",
+                "&has_primary_ip=True",
+                "&sort=name",
+            ]
+            create_url = self.get_view_url_for_saved_view(action="create")
+            sv_name = "Devices with primary ips"
+            request = {
+                "path": create_url,
+                "data": post_data({"name": sv_name, "view": f"{view_name}", "params": "".join(create_query_strings)}),
+            }
+            self.assertHttpStatus(self.client.post(**request), 302)
+            instance = SavedView.objects.get(name=sv_name)
+            self.assertEqual(instance.config["pagination_count"], 12)
+            self.assertEqual(instance.config["filter_params"]["has_primary_ip"], "True")
+            self.assertEqual(instance.config["sort_order"], ["name"])
+            response = self.client.get(reverse(view_name) + "?saved_view=" + str(instance.pk), follow=True)
+            # Assert that Job List View rendered with the boolean filter parameter without error
+            self.assertHttpStatus(response, 200)
+            response_body = extract_page_body(response.content.decode(response.charset))
+            self.assertIn(str(instance.pk), response_body, msg=response_body)
+            self.assertBodyContains(response, f"<strong>{sv_name}</strong>", html=True)
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_update_saved_view_contain_boolean_filter_params(self):
+        with self.subTest("Update job Saved View with boolean filter parameters"):
+            view_name = "extras:job_list"
+            sv_name = "Non-hidden jobs"
+            instance = SavedView.objects.create(
+                name=sv_name,
+                owner=self.user,
+                view=view_name,
+            )
+            update_query_strings = ["hidden=False"]
+            update_url = self.get_view_url_for_saved_view(instance, "edit") + "?" + "".join(update_query_strings)
+            # Try update the saved view with the same user as the owner of the saved view
+            instance.owner.is_active = True
+            instance.owner.save()
+            self.client.force_login(instance.owner)
+            response = self.client.get(update_url)
+            self.assertHttpStatus(response, 302)
+            instance.refresh_from_db()
+            self.assertEqual(instance.config["filter_params"]["hidden"], "False")
+            response = self.client.get(reverse(view_name) + "?saved_view=" + str(instance.pk), follow=True)
+            # Assert that Job List View rendered with the boolean filter parameter without error
+            self.assertHttpStatus(response, 200)
+            response_body = extract_page_body(response.content.decode(response.charset))
+            self.assertNotIn("Example hidden job", response_body, msg=response_body)
+            self.assertBodyContains(response, f"<strong>{sv_name}</strong>", html=True)
+
+        with self.subTest("Update device Saved View with boolean filter parameters"):
+            view_name = "dcim:device_list"
+            sv_name = "Devices with no primary ips"
+            instance = SavedView.objects.create(
+                name=sv_name,
+                owner=self.user,
+                view=view_name,
+            )
+            update_query_strings = ["has_primary_ip=False"]
+            update_url = self.get_view_url_for_saved_view(instance, "edit") + "?" + "".join(update_query_strings)
+            # Try update the saved view with the same user as the owner of the saved view
+            instance.owner.is_active = True
+            instance.owner.save()
+            self.client.force_login(instance.owner)
+            response = self.client.get(update_url)
+            self.assertHttpStatus(response, 302)
+            instance.refresh_from_db()
+            self.assertEqual(instance.config["filter_params"]["has_primary_ip"], "False")
+            response = self.client.get(reverse(view_name) + "?saved_view=" + str(instance.pk), follow=True)
+            # Assert that Job List View rendered with the boolean filter parameter without error
+            self.assertHttpStatus(response, 200)
+            response_body = extract_page_body(response.content.decode(response.charset))
+            self.assertBodyContains(response, f"<strong>{sv_name}</strong>", html=True)
+
 
 # Not a full-fledged PrimaryObjectViewTestCase as there's no BulkEditView for Secrets
 class SecretTestCase(