nautobot 2.3.6__py3-none-any.whl → 2.3.7__py3-none-any.whl

nautobot/core/testing/views.py

@@ -144,6 +144,7 @@ class ViewTestCases:
             self.client.logout()
             response = self.client.get(self._get_queryset().first().get_absolute_url())
             self.assertHttpStatus(response, 200)
+            # TODO: all this is doing is checking that a login link appears somewhere on the page (i.e. in the nav).
             response_body = response.content.decode(response.charset)
             self.assertIn(
                 "/login/?next=" + self._get_queryset().first().get_absolute_url(), response_body, msg=response_body
@@ -151,8 +152,7 @@ class ViewTestCases:
 
             # The "Change Log" tab should appear in the response since we have all exempt permissions
             if issubclass(self.model, extras_models.ChangeLoggedModel):
-                response_body = utils.extract_page_body(response.content.decode(response.charset))
-                self.assertIn("Change Log", response_body, msg=response_body)
+                self.assertBodyContains(response, "Change Log")
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_get_object_without_permission(self):
@@ -177,41 +177,33 @@ class ViewTestCases:
 
             # Try GET with model-level permission
             response = self.client.get(instance.get_absolute_url())
-            self.assertHttpStatus(response, 200)
-
-            response_body = utils.extract_page_body(response.content.decode(response.charset))
-
-            # The object's display name or string representation should appear in the response
-            self.assertIn(escape(getattr(instance, "display", str(instance))), response_body, msg=response_body)
+            # The object's display name or string representation should appear in the response body
+            self.assertBodyContains(response, escape(getattr(instance, "display", str(instance))))
 
             # If any Relationships are defined, they should appear in the response
             if self.relationships is not None:
                 for relationship in self.relationships:  # false positive pylint: disable=not-an-iterable
                     content_type = ContentType.objects.get_for_model(instance)
                     if content_type == relationship.source_type:
-                        self.assertIn(
+                        self.assertBodyContains(
+                            response,
                             escape(relationship.get_label(extras_choices.RelationshipSideChoices.SIDE_SOURCE)),
-                            response_body,
-                            msg=response_body,
                         )
                     if content_type == relationship.destination_type:
-                        self.assertIn(
+                        self.assertBodyContains(
+                            response,
                             escape(relationship.get_label(extras_choices.RelationshipSideChoices.SIDE_DESTINATION)),
-                            response_body,
-                            msg=response_body,
                         )
 
             # If any Custom Fields are defined, they should appear in the response
             if self.custom_fields is not None:
                 for custom_field in self.custom_fields:  # false positive pylint: disable=not-an-iterable
-                    self.assertIn(escape(str(custom_field)), response_body, msg=response_body)
+                    self.assertBodyContains(response, escape(str(custom_field)))
                     if custom_field.type == extras_choices.CustomFieldTypeChoices.TYPE_MULTISELECT:
                         for value in instance.cf.get(custom_field.key):
-                            self.assertIn(escape(str(value)), response_body, msg=response_body)
+                            self.assertBodyContains(response, escape(str(value)))
                     else:
-                        self.assertIn(
-                            escape(str(instance.cf.get(custom_field.key) or "")), response_body, msg=response_body
-                        )
+                        self.assertBodyContains(response, escape(str(instance.cf.get(custom_field.key) or "")))
 
             return response  # for consumption by child test cases if desired
 
@@ -251,11 +243,8 @@ class ViewTestCases:
             obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
 
             response = self.client.get(instance.get_absolute_url())
-            response_body = utils.extract_page_body(response.content.decode(response.charset))
-            advanced_tab_href = f"{instance.get_absolute_url()}#advanced"
-
-            self.assertIn(advanced_tab_href, response_body)
-            self.assertIn("Advanced", response_body)
+            self.assertBodyContains(response, f"{instance.get_absolute_url()}#advanced")
+            self.assertBodyContains(response, "Advanced")
 
     class GetObjectChangelogViewTestCase(ModelViewTestCase):
         """
@@ -268,12 +257,16 @@ class ViewTestCases:
             url = self._get_url("changelog", obj)
             response = self.client.get(url)
             self.assertHttpStatus(response, 200)
-            response_data = response.content.decode(response.charset)
+
+            # Test for https://github.com/nautobot/nautobot/issues/5214
             if getattr(obj, "is_contact_associable_model", False):
-                self.assertInHTML(
+                self.assertBodyContains(
+                    response,
                     f'<a href="{obj.get_absolute_url()}#contacts" onclick="switch_tab(this.href)" aria-controls="contacts" role="tab" data-toggle="tab">Contacts</a>',
-                    response_data,
+                    html=True,
                 )
+            else:
+                self.assertNotContains(response, f"{obj.get_absolute_url()}#contacts")
 
     class GetObjectNotesViewTestCase(ModelViewTestCase):
         """
@@ -287,12 +280,16 @@ class ViewTestCases:
                 url = self._get_url("notes", obj)
                 response = self.client.get(url)
                 self.assertHttpStatus(response, 200)
-                response_data = response.content.decode(response.charset)
+
+                # Test for https://github.com/nautobot/nautobot/issues/5214
                 if getattr(obj, "is_contact_associable_model", False):
-                    self.assertInHTML(
+                    self.assertBodyContains(
+                        response,
                         f'<a href="{obj.get_absolute_url()}#contacts" onclick="switch_tab(this.href)" aria-controls="contacts" role="tab" data-toggle="tab">Contacts</a>',
-                        response_data,
+                        html=True,
                     )
+                else:
+                    self.assertNotContains(response, f"{obj.get_absolute_url()}#contacts")
 
     class CreateObjectViewTestCase(ModelViewTestCase):
         """
@@ -366,11 +363,9 @@ class ViewTestCases:
                     detail_url = instance.get_absolute_url()
                     validate(detail_url)
                     response = self.client.get(detail_url)
-                    response_body = utils.extract_page_body(response.content.decode(response.charset))
-                    advanced_tab_href = f"{detail_url}#advanced"
-                    self.assertIn(advanced_tab_href, response_body)
-                    self.assertIn("<td>Created By</td>", response_body)
-                    self.assertIn("<td>nautobotuser</td>", response_body)
+                    self.assertBodyContains(response, f"{detail_url}#advanced")
+                    self.assertBodyContains(response, "<td>Created By</td>", html=True)
+                    self.assertBodyContains(response, f"<td>{self.user.username}</td>", html=True)
                 except (AttributeError, ValidationError):
                     # Instance does not have a valid detail view, do nothing here.
                     pass
@@ -522,11 +517,9 @@ class ViewTestCases:
                     detail_url = instance.get_absolute_url()
                     validate(detail_url)
                     response = self.client.get(detail_url)
-                    response_body = utils.extract_page_body(response.content.decode(response.charset))
-                    advanced_tab_href = f"{detail_url}#advanced"
-                    self.assertIn(advanced_tab_href, response_body)
-                    self.assertIn("<td>Last Updated By</td>", response_body)
-                    self.assertIn("<td>nautobotuser</td>", response_body)
+                    self.assertBodyContains(response, f"{detail_url}#advanced")
+                    self.assertBodyContains(response, "<td>Last Updated By</td>", html=True)
+                    self.assertBodyContains(response, f"<td>{self.user.username}</td>", html=True)
                 except (AttributeError, ValidationError):
                     # Instance does not have a valid detail view, do nothing here.
                     pass
@@ -763,8 +756,7 @@ class ViewTestCases:
 
             with self.subTest("Assert indentation is present"):
                 response = self.client.get(f"{self._get_url('list')}")
-                response_body = response.content.decode(response.charset)
-                self.assertInHTML('<i class="mdi mdi-circle-small"></i>', response_body)
+                self.assertBodyContains(response, '<i class="mdi mdi-circle-small"></i>', html=True)
 
             with self.subTest("Assert indentation is removed on filter"):
                 queryset = (
@@ -786,6 +778,7 @@ class ViewTestCases:
             self.client.logout()
             response = self.client.get(self._get_url("list"))
             self.assertHttpStatus(response, 200)
+            # TODO: all this is doing is checking that a login link appears somewhere on the page (i.e. in the nav).
             response_body = response.content.decode(response.charset)
             self.assertIn("/login/?next=" + self._get_url("list"), response_body, msg=response_body)
 
@@ -799,7 +792,6 @@ class ViewTestCases:
             response = self.client.get(f"{self._get_url('list')}?id={instance1.pk}")
             self.assertHttpStatus(response, 200)
             content = utils.extract_page_body(response.content.decode(response.charset))
-            # TODO: it'd make test failures more readable if we strip the page headers/footers from the content
             if hasattr(self.model, "name"):
                 self.assertRegex(content, r">\s*" + re.escape(escape(instance1.name)) + r"\s*<", msg=content)
                 self.assertNotRegex(content, r">\s*" + re.escape(escape(instance2.name)) + r"\s*<", msg=content)
@@ -810,12 +802,9 @@ class ViewTestCases:
         def test_list_objects_unknown_filter_strict_filtering(self):
             """Verify that with STRICT_FILTERING, an unknown filter results in an error message and no matches."""
             response = self.client.get(f"{self._get_url('list')}?ice_cream_flavor=chocolate")
-            self.assertHttpStatus(response, 200)
-            content = utils.extract_page_body(response.content.decode(response.charset))
-            # TODO: it'd make test failures more readable if we strip the page headers/footers from the content
-            self.assertIn("Unknown filter field", content, msg=content)
+            self.assertBodyContains(response, "Unknown filter field")
             # There should be no table rows displayed except for the empty results row
-            self.assertIn("None", content, msg=content)
+            self.assertBodyContains(response, "None")
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"], STRICT_FILTERING=False)
         def test_list_objects_unknown_filter_no_strict_filtering(self):
@@ -842,7 +831,6 @@ class ViewTestCases:
             )
             self.assertHttpStatus(response, 200)
             content = utils.extract_page_body(response.content.decode(response.charset))
-            # TODO: it'd make test failures more readable if we strip the page headers/footers from the content
             self.assertNotIn("Unknown filter field", content, msg=content)
             self.assertIn("None", content, msg=content)
             if hasattr(self.model, "name"):
@@ -871,16 +859,13 @@ class ViewTestCases:
             # Try GET with model-level permission
             response = self.client.get(self._get_url("list"))
             self.assertHttpStatus(response, 200)
-            response_body = response.content.decode(response.charset)
+            response_body = utils.extract_page_body(response.content.decode(response.charset))
 
             list_url = self.get_list_url()
             title = self.get_title()
 
             # Check if breadcrumb is rendered correctly
-            self.assertIn(
-                f'<a href="{list_url}">{title}</a>',
-                response_body,
-            )
+            self.assertBodyContains(response, f'<a href="{list_url}">{title}</a>', html=True)
 
             # Check if import button is absent due to user permissions
             self.assertNotIn(
@@ -909,7 +894,6 @@ class ViewTestCases:
             response = self.client.get(self._get_url("list"))
             self.assertHttpStatus(response, 200)
             content = utils.extract_page_body(response.content.decode(response.charset))
-            # TODO: it'd make test failures more readable if we strip the page headers/footers from the content
             if hasattr(self.model, "name"):
                 self.assertRegex(content, r">\s*" + re.escape(escape(instance1.name)) + r"\s*<", msg=content)
                 self.assertNotRegex(content, r">\s*" + re.escape(escape(instance2.name)) + r"\s*<", msg=content)
@@ -953,12 +937,12 @@ class ViewTestCases:
 
             # Try GET with model-level permission
             response = self.client.get(self._get_url("list"))
-            self.assertHttpStatus(response, 200)
-            response_body = response.content.decode(response.charset)
 
             # Check app banner is rendered correctly
-            self.assertIn(
-                f"<div>You are viewing a table of {self.model._meta.verbose_name_plural}</div>", response_body
+            self.assertBodyContains(
+                response,
+                f"<div>You are viewing a table of {self.model._meta.verbose_name_plural}</div>",
+                html=True,
             )
 
     class CreateMultipleObjectsViewTestCase(ModelViewTestCase):
@@ -1596,7 +1580,7 @@ class ViewTestCases:
                     f"Renaming {len(objects)} {helpers.bettertitle(verbose_name_plural)} "
                     f"on {self.selected_objects_parent_name}"
                 )
-                self.assertInHTML(message, response.content.decode(response.charset))
+                self.assertBodyContains(response, message)
 
             with self.subTest("Assert update successfully"):
                 data["_apply"] = True  # Form Apply button
@@ -1611,4 +1595,4 @@ class ViewTestCases:
                     data["pk"] = values
                     response = self.client.post(self._get_url("bulk_rename"), data, follow=True)
                     expected_message = f"No valid {verbose_name_plural} were selected."
-                    self.assertIn(expected_message, response.content.decode(response.charset))
+                    self.assertBodyContains(response, expected_message)

nautobot/core/tests/runner.py

@@ -157,8 +157,9 @@ class NautobotTestRunner(DiscoverRunner):
                                     suffix=str(index + 1),
                                     verbosity=self.verbosity,
                                     keepdb=self.keepdb
-                                    # Extra check added for Nautobot:
-                                    and self.reusedb,
+                                    # Extra checks added for Nautobot:
+                                    and self.reusedb
+                                    and not settings.TEST_USE_FACTORIES,  # w/ factory data, clones can't be reused
                                 )
 
                 # Configure all other connections as mirrors of the first one
@@ -188,7 +189,9 @@ class NautobotTestRunner(DiscoverRunner):
                         connection.creation.destroy_test_db(
                             suffix=str(index + 1),
                             verbosity=self.verbosity,
-                            keepdb=self.keepdb,
+                            keepdb=self.keepdb
+                            # Extra check added for Nautobot
+                            and not settings.TEST_USE_FACTORIES,  # with factory data, clones cannot be reused
                         )
 
                 # Extra block added for Nautobot

nautobot/core/tests/test_paginator.py

@@ -8,6 +8,7 @@ from django.urls import reverse
 
 from nautobot.circuits import models as circuits_models
 from nautobot.core import testing
+from nautobot.core.testing.utils import extract_page_body
 from nautobot.core.views import paginator
 from nautobot.dcim import models as dcim_models
 from nautobot.extras import models as extras_models
@@ -75,7 +76,7 @@ class PaginatorTestCase(testing.TestCase):
             warning_message = (
                 "Requested "per_page" is too large. No more than 10 items may be displayed at a time."
             )
-            self.assertIn(warning_message, response.content.decode(response.charset))
+            self.assertIn(warning_message, extract_page_body(response.content.decode(response.charset)))
         with self.subTest("query parameter per_page=5 returns 5 rows"):
             response = self.client.get(url, {"per_page": 5})
             self.assertHttpStatus(response, 200)
@@ -97,7 +98,7 @@ class PaginatorTestCase(testing.TestCase):
             warning_message = (
                 "Requested "per_page" is too large. No more than 10 items may be displayed at a time."
             )
-            self.assertIn(warning_message, response.content.decode(response.charset).replace("\n", ""))
+            self.assertIn(warning_message, extract_page_body(response.content.decode(response.charset)))
 
     @override_settings(MAX_PAGE_SIZE=0)
     def test_error_warning_not_shown_when_max_page_size_is_0(self):
@@ -118,4 +119,4 @@ class PaginatorTestCase(testing.TestCase):
             self.assertEqual(response.context["paginator"].per_page, 20)
             self.assertEqual(len(response.context["table"].page), 20)
             warning_message = "Requested "per_page" is too large."
-            self.assertNotIn(warning_message, response.content.decode(response.charset))
+            self.assertNotIn(warning_message, extract_page_body(response.content.decode(response.charset)))

nautobot/core/tests/test_views.py

@@ -14,6 +14,7 @@ from prometheus_client.parser import text_string_to_metric_families
 from nautobot.core.constants import GLOBAL_SEARCH_EXCLUDE_LIST
 from nautobot.core.testing import TestCase
 from nautobot.core.testing.api import APITestCase
+from nautobot.core.testing.utils import extract_page_body
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.core.views import NautobotMetricsView
 from nautobot.core.views.mixins import GetReturnURLMixin
@@ -154,16 +155,15 @@ class HomeViewTestCase(TestCase):
             BANNER_BOTTOM="[info](https://nautobot.com)",
         ):
             response = self.client.get(url)
-        self.assertInHTML("<h1>Hello world</h1>", response.content.decode(response.charset))
-        self.assertInHTML(
-            '<a href="https://nautobot.com" rel="noopener noreferrer">info</a>',
-            response.content.decode(response.charset),
+        self.assertBodyContains(response, "<h1>Hello world</h1>", html=True)
+        self.assertBodyContains(
+            response, '<a href="https://nautobot.com" rel="noopener noreferrer">info</a>', html=True
         )
 
         with override_settings(BANNER_LOGIN="_Welcome to Nautobot!_"):
             self.client.logout()
             response = self.client.get(reverse("login"))
-        self.assertInHTML("<em>Welcome to Nautobot!</em>", response.content.decode(response.charset))
+        self.assertBodyContains(response, "<em>Welcome to Nautobot!</em>", html=True)
 
     def test_banners_no_xss(self):
         url = reverse("home")
@@ -195,21 +195,24 @@ class SearchFieldsTestCase(TestCase):
 
         # Assert model search bar present in list UI
         response = self.client.get(reverse("dcim:location_list"))
-        self.assertInHTML(
+        self.assertBodyContains(
+            response,
             '<input type="text" name="q" class="form-control" required placeholder="Search Locations" id="id_q">',
-            response.content.decode(response.charset),
+            html=True,
         )
 
         response = self.client.get(reverse("dcim:device_list"))
-        self.assertInHTML(
+        self.assertBodyContains(
+            response,
             '<input type="text" name="q" class="form-control" required placeholder="Search Devices" id="id_q">',
-            response.content.decode(response.charset),
+            html=True,
         )
 
         # Assert global search bar present in UI
-        self.assertInHTML(
+        self.assertContains(  # not using assertBodyContains because this is in the nav
+            response,
             '<input type="text" name="q" class="form-control" placeholder="Search Nautobot">',
-            response.content.decode(response.charset),
+            html=True,
         )
 
 
@@ -233,16 +236,10 @@ class FilterFormsTestCase(TestCase):
             """
 
         response = self.client.get(reverse("dcim:location_list"))
-        self.assertInHTML(
-            filter_tabs,
-            response.content.decode(response.charset),
-        )
+        self.assertBodyContains(response, filter_tabs, html=True)
 
         response = self.client.get(reverse("circuits:circuit_list"))
-        self.assertInHTML(
-            filter_tabs,
-            response.content.decode(response.charset),
-        )
+        self.assertBodyContains(response, filter_tabs, html=True)
 
     def test_filtering_on_custom_select_filter_field(self):
         """Assert CustomField select and multiple select fields can be filtered using multiple entries"""
@@ -271,10 +268,8 @@ class FilterFormsTestCase(TestCase):
         )
         url = reverse("dcim:location_list") + query_param
         response = self.client.get(url)
-        self.assertHttpStatus(response, 200)
-        response_content = response.content.decode(response.charset).replace("\n", "")
-        self.assertInHTML(locations[0].name, response_content)
-        self.assertInHTML(locations[1].name, response_content)
+        self.assertBodyContains(response, locations[0].name, html=True)
+        self.assertBodyContains(response, locations[1].name, html=True)
 
     def test_filtering_crafted_query_params(self):
         """Test for reflected-XSS vulnerability GHSA-jxgr-gcj5-cqqg."""
@@ -282,17 +277,16 @@ class FilterFormsTestCase(TestCase):
         query_param = "?location_type=1 onmouseover=alert('hi') foo=bar"
         url = reverse("dcim:location_list") + query_param
         response = self.client.get(url)
-        self.assertHttpStatus(response, 200)
-        response_content = response.content.decode(response.charset)
         # The important thing here is that the data-field-parent and data-field-value are correctly quoted
-        self.assertInHTML(
+        self.assertBodyContains(
+            response,
             """
 <span class="filter-selection-choice-remove remove-filter-param"
       data-field-type="child"
       data-field-parent="location_type"
       data-field-value="1 onmouseover=alert(&#x27;hi&#x27;) foo=bar"
 >×</span>""",  # noqa: RUF001 - ambiguous-unicode-character-string
-            response_content,
+            html=True,
         )
 
 
@@ -327,21 +321,18 @@ class NavAppsUITestCase(TestCase):
         self.url = reverse("apps:apps_list")
         self.item_weight = 100  # TODO: not easy to introspect from the nav menu struct, so hard-code it here for now
 
-    def make_request(self):
-        response = self.client.get(reverse("home"))
-        return response.content.decode(response.charset)
-
     def test_installed_apps_visible(self):
         """The "Installed Apps" menu item should be available to an authenticated user regardless of permissions."""
-        response_content = self.make_request()
-        self.assertInHTML(
+        response = self.client.get(reverse("home"))
+        self.assertContains(
+            response,
             f"""
             <a href="{self.url}"
                 data-item-weight="{self.item_weight}">
                 Installed Apps
             </a>
             """,
-            response_content,
+            html=True,
         )
 
 
@@ -361,7 +352,7 @@ class LoginUITestCase(TestCase):
     def make_request(self):
         response = self.client.get(reverse("login"))
         sso_login_pattern = re.compile('<a href=".*">Continue with SSO</a>')
-        return sso_login_pattern.search(response.content.decode(response.charset))
+        return sso_login_pattern.search(extract_page_body(response.content.decode(response.charset)))
 
     def test_sso_login_button_not_visible(self):
         """Test Continue with SSO button not visible if SSO is enabled"""
@@ -458,13 +449,13 @@ class ErrorPagesTestCase(TestCase):
         """Nautobot's custom 404 page should be used and should include a default support message."""
         with self.assertTemplateUsed("404.html"):
             response = self.client.get("/foo/bar")
-        self.assertContains(response, "Network to Code", status_code=404)
-        response_content = response.content.decode(response.charset)
-        self.assertInHTML(
+        self.assertBodyContains(
+            response,
             "If further assistance is required, please join the <code>#nautobot</code> channel on "
             '<a href="https://slack.networktocode.com/" rel="noopener noreferrer">Network to Code\'s '
             "Slack community</a> and post your question.",
-            response_content,
+            html=True,
+            status_code=404,
         )
 
     @override_settings(DEBUG=False, SUPPORT_MESSAGE="Hello world!")
@@ -473,8 +464,7 @@ class ErrorPagesTestCase(TestCase):
         with self.assertTemplateUsed("404.html"):
             response = self.client.get("/foo/bar")
         self.assertNotContains(response, "Network to Code", status_code=404)
-        response_content = response.content.decode(response.charset)
-        self.assertInHTML("Hello world!", response_content)
+        self.assertBodyContains(response, "Hello world!", status_code=404)
 
     @override_settings(DEBUG=False)
     @mock.patch("nautobot.core.views.HomeView.get", side_effect=Exception)
@@ -484,13 +474,13 @@ class ErrorPagesTestCase(TestCase):
         self.client.raise_request_exception = False
         response = self.client.get(url)
         self.assertTemplateUsed(response, "500.html")
-        self.assertContains(response, "Network to Code", status_code=500)
-        response_content = response.content.decode(response.charset)
-        self.assertInHTML(
+        self.assertBodyContains(
+            response,
             "If further assistance is required, please join the <code>#nautobot</code> channel on "
             '<a href="https://slack.networktocode.com/" rel="noopener noreferrer">Network to Code\'s '
             "Slack community</a> and post your question.",
-            response_content,
+            html=True,
+            status_code=500,
         )
 
     @override_settings(DEBUG=False, SUPPORT_MESSAGE="Hello world!")
@@ -502,8 +492,7 @@ class ErrorPagesTestCase(TestCase):
         response = self.client.get(url)
         self.assertTemplateUsed(response, "500.html")
         self.assertNotContains(response, "Network to Code", status_code=500)
-        response_content = response.content.decode(response.charset)
-        self.assertInHTML("Hello world!", response_content)
+        self.assertBodyContains(response, "Hello world!", status_code=500)
 
 
 class DBFileStorageViewTestCase(TestCase):
@@ -591,23 +580,17 @@ class ExampleViewWithCustomPermissionsTest(TestCase):
         self.client.logout()
         url = reverse("plugins:example_app:view_with_custom_permissions")
         response = self.client.get(url, follow=True)
-        self.assertHttpStatus(response, 200)
-        response_body = response.content.decode(response.charset)
         # check if the user is redirected to the login page
-        self.assertIn(f'<input type="hidden" name="next" value="{url}" />', response_body)
+        self.assertBodyContains(response, f'<input type="hidden" name="next" value="{url}" />', html=True)
 
         # Test IsAdmin permission
         self.client.force_login(self.user)
         response = self.client.get(url, follow=True)
-        self.assertHttpStatus(response, 403)
-        response_body = response.content.decode(response.charset)
         # check if the users have to have the permission to access the page
-        self.assertIn("You do not have permission to access this page.", response_body)
+        self.assertBodyContains(response, "You do not have permission to access this page", status_code=403)
 
         # View should be successfully accessed
         self.user.is_staff = True
         self.user.save()
         response = self.client.get(url)
-        self.assertHttpStatus(response, 200)
-        response_body = response.content.decode(response.charset)
-        self.assertIn("You are viewing a table of example models", response_body)
+        self.assertBodyContains(response, "You are viewing a table of example models")

nautobot/core/views/__init__.py

@@ -1,3 +1,5 @@
+import contextlib
+import logging
 import os
 import platform
 import re
@@ -32,6 +34,7 @@ from prometheus_client import (
 )
 from prometheus_client.metrics_core import GaugeMetricFamily
 from prometheus_client.registry import Collector
+import redis.exceptions
 from rest_framework.permissions import AllowAny, IsAuthenticated
 from rest_framework.renderers import BaseRenderer
 from rest_framework.response import Response
@@ -48,6 +51,8 @@ from nautobot.extras.forms import GraphQLQueryForm
 from nautobot.extras.models import FileProxy, GraphQLQuery, Status
 from nautobot.extras.registry import registry
 
+logger = logging.getLogger(__name__)
+
 
 class HomeView(AccessMixin, TemplateView):
     template_name = "home.html"
@@ -154,26 +159,37 @@ class WorkerStatusView(UserPassesTestMixin, TemplateView):
             timeout = max_timeout
         else:
             timeout = int(timeout)
-        celery_inspect = app.control.inspect(timeout=timeout)
 
-        # stats() returns a dict of {worker_name: stats_dict}
-        worker_stats = celery_inspect.stats()
+        celery_inspect = app.control.inspect(timeout=timeout)
 
+        try:
+            # stats() returns a dict of {worker_name: stats_dict}
+            worker_stats = celery_inspect.stats()
+        except redis.exceptions.ConnectionError:
+            # Celery seems to be not smart enough to auto-retry on intermittent failures, so let's do it ourselves:
+            try:
+                worker_stats = celery_inspect.stats()
+            except redis.exceptions.ConnectionError as err:
+                logger.error("Repeated ConnectionError from Celery/Redis: %s", err)
+                worker_stats = None
+
+        active_tasks = reserved_tasks = active_queues = {}
         if worker_stats:
             # Set explicit list of workers to speed up subsequent queries
             celery_inspect = app.control.inspect(list(worker_stats.keys()), timeout=5.0)
 
-            # active() returns a dict of {worker_name: [task_dict, task_dict, ...]}
-            active_tasks = celery_inspect.active() or {}
+            with contextlib.suppress(redis.exceptions.ConnectionError):
+                # active() returns a dict of {worker_name: [task_dict, task_dict, ...]}
+                active_tasks = celery_inspect.active() or {}
 
-            # reserved() returns a dict of {worker_name: [task_dict, task_dict, ...]}
-            reserved_tasks = celery_inspect.reserved() or {}
+                # reserved() returns a dict of {worker_name: [task_dict, task_dict, ...]}
+                reserved_tasks = celery_inspect.reserved() or {}
 
-            # active_queues() returns a dict of {worker_name: [queue_dict, queue_dict, ...]}
-            active_queues = celery_inspect.active_queues() or {}
+                # active_queues() returns a dict of {worker_name: [queue_dict, queue_dict, ...]}
+                active_queues = celery_inspect.active_queues() or {}
         else:
-            # No workers were found, default to empty dicts for all commands
-            worker_stats = active_tasks = reserved_tasks = active_queues = {}
+            # No workers were found
+            worker_stats = {}
 
         workers = []
         for worker_name in sorted(worker_stats, key=sort_workers):