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

nautobot/extras/tests/test_views.py

@@ -864,11 +864,9 @@ class DynamicGroupTestCase(
         url = reverse("dcim:device_dynamicgroups", kwargs={"pk": Device.objects.first().pk})
         self.add_permissions("dcim.view_device", "extras.view_dynamicgroup")
         response = self.client.get(url)
-        self.assertHttpStatus(response, 200)
-        response_body = response.content.decode(response.charset)
-        self.assertIn("DG 1", response_body, msg=response_body)
-        self.assertIn("DG 2", response_body, msg=response_body)
-        self.assertIn("DG 3", response_body, msg=response_body)
+        self.assertBodyContains(response, "DG 1")
+        self.assertBodyContains(response, "DG 2")
+        self.assertBodyContains(response, "DG 3")
 
     def test_get_object_dynamic_groups_with_constrained_permission(self):
         obj_perm = ObjectPermission(
@@ -891,7 +889,7 @@ class DynamicGroupTestCase(
         url = reverse("dcim:device_dynamicgroups", kwargs={"pk": Device.objects.first().pk})
         response = self.client.get(url)
         self.assertHttpStatus(response, 200)
-        response_body = response.content.decode(response.charset)
+        response_body = extract_page_body(response.content.decode(response.charset))
         self.assertIn("DG 1", response_body, msg=response_body)
         self.assertNotIn("DG 2", response_body, msg=response_body)
         self.assertNotIn("DG 3", response_body, msg=response_body)
@@ -1334,18 +1332,14 @@ class SavedViewTest(ModelViewTestCase):
         # Try GET with model-level permission
         # SavedView detail view should redirect to the View from which it is derived
         response = self.client.get(instance.get_absolute_url(), follow=True)
-        self.assertHttpStatus(response, 200)
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn(escape(instance.name), response_body, msg=response_body)
+        self.assertBodyContains(response, escape(instance.name))
 
         query_strings = ["&table_changes_pending=true", "&per_page=1234", "&status=active", "&sort=name"]
         for string in query_strings:
             view_url = self.get_view_url_for_saved_view(instance) + string
             response = self.client.get(view_url)
-            self.assertHttpStatus(response, 200)
-            response_body = extract_page_body(response.content.decode(response.charset))
             # Assert that the star sign is rendered on the page since there are unsaved changes
-            self.assertIn('<i title="Pending changes not saved">', response_body, msg=response_body)
+            self.assertBodyContains(response, '<i title="Pending changes not saved">')
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
     def test_get_object_with_constrained_permission(self):
@@ -1383,12 +1377,9 @@ class SavedViewTest(ModelViewTestCase):
         # Try update the saved view with a different user from the owner of the saved view
         self.client.force_login(different_user)
         response = self.client.get(update_url, follow=True)
-        self.assertHttpStatus(response, 200)
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn(
+        self.assertBodyContains(
+            response,
             f"You do not have the required permission to modify this Saved View owned by {instance.owner}",
-            response_body,
-            msg=response_body,
         )
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
@@ -1424,12 +1415,9 @@ class SavedViewTest(ModelViewTestCase):
         # Try delete the saved view with a different user from the owner of the saved view
         self.client.force_login(different_user)
         response = self.client.post(delete_url, follow=True)
-        self.assertHttpStatus(response, 200)
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn(
+        self.assertBodyContains(
+            response,
             f"You do not have the required permission to delete this Saved View owned by {instance.owner}",
-            response_body,
-            msg=response_body,
         )
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
@@ -1450,13 +1438,7 @@ class SavedViewTest(ModelViewTestCase):
         instance.owner.save()
         self.client.force_login(instance.owner)
         response = self.client.post(delete_url, follow=True)
-        self.assertHttpStatus(response, 200)
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn(
-            "Are you sure you want to delete saved view",
-            response_body,
-            msg=response_body,
-        )
+        self.assertBodyContains(response, "Are you sure you want to delete saved view")
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_create_saved_view(self):
@@ -1499,16 +1481,7 @@ class SavedViewTest(ModelViewTestCase):
         )
         response = self.client.get(reverse(view_name), follow=True)
         # Assert that Location List View got redirected to Saved View set as global default
-        self.assertHttpStatus(response, 200)
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertInHTML(
-            """
-            <strong>
-                Global Location Default View
-            </strong>
-            """,
-            response_body,
-        )
+        self.assertBodyContains(response, "<strong>Global Location Default View</strong>", html=True)
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_user_default(self):
@@ -1522,16 +1495,7 @@ class SavedViewTest(ModelViewTestCase):
         UserSavedViewAssociation.objects.create(user=self.user, saved_view=sv, view_name=sv.view)
         response = self.client.get(reverse(view_name), follow=True)
         # Assert that Location List View got redirected to Saved View set as user default
-        self.assertHttpStatus(response, 200)
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertInHTML(
-            """
-            <strong>
-                User Location Default View
-            </strong>
-            """,
-            response_body,
-        )
+        self.assertBodyContains(response, "<strong>User Location Default View</strong>", html=True)
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_user_default_precedes_global_default(self):
@@ -1550,16 +1514,7 @@ class SavedViewTest(ModelViewTestCase):
         UserSavedViewAssociation.objects.create(user=self.user, saved_view=sv, view_name=sv.view)
         response = self.client.get(reverse(view_name), follow=True)
         # Assert that Location List View got redirected to Saved View set as user default
-        self.assertHttpStatus(response, 200)
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertInHTML(
-            """
-            <strong>
-                User Location Default View
-            </strong>
-            """,
-            response_body,
-        )
+        self.assertBodyContains(response, "<strong>User Location Default View</strong>", html=True)
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
     def test_is_shared(self):
@@ -1914,12 +1869,8 @@ class ApprovalQueueTestCase(
 
         # Try GET with model-level permission
         response = self.client.get(self._get_url("view", instance))
-        self.assertHttpStatus(response, 200)
-
-        response_body = extract_page_body(response.content.decode(response.charset))
-
         # The object's display name or string representation should appear in the response
-        self.assertIn(getattr(instance, "display", str(instance)), response_body, msg=response_body)
+        self.assertBodyContains(response, getattr(instance, "display", str(instance)))
 
         # skip GetObjectViewTestCase checks for Relationships and Custom Fields since this isn't actually a detail view
 
@@ -1954,9 +1905,7 @@ class ApprovalQueueTestCase(
         """Anonymous users may not take any action with regard to job approval requests."""
         self.client.logout()
         response = self.client.post(self._get_url("view", self._get_queryset().first()))
-        self.assertHttpStatus(response, 200)
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn("You do not have permission to run jobs", response_body)
+        self.assertBodyContains(response, "You do not have permission to run jobs")
         # No job was submitted
         self.assertFalse(JobResult.objects.filter(name=self.job_model.name).exists())
 
@@ -1968,9 +1917,7 @@ class ApprovalQueueTestCase(
         data = {"_dry_run": True}
 
         response = self.client.post(self._get_url("view", instance), data)
-        self.assertHttpStatus(response, 200)
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn("This job cannot be run at this time", response_body)
+        self.assertBodyContains(response, "This job cannot be run at this time")
         # No job was submitted
         self.assertFalse(JobResult.objects.filter(name=instance.job_model.name).exists())
 
@@ -1984,9 +1931,7 @@ class ApprovalQueueTestCase(
         data = {"_dry_run": True}
 
         response = self.client.post(self._get_url("view", instance), data)
-        self.assertHttpStatus(response, 200)
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn("You do not have permission to run this job", response_body)
+        self.assertBodyContains(response, "You do not have permission to run this job")
         # No job was submitted
         self.assertFalse(JobResult.objects.filter(name=instance.job_model.name).exists())
 
@@ -2006,9 +1951,7 @@ class ApprovalQueueTestCase(
         instance2.job_model.save()
 
         response = self.client.post(self._get_url("view", instance2), data)
-        self.assertHttpStatus(response, 200)
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn("You do not have permission to run this job", response_body)
+        self.assertBodyContains(response, "You do not have permission to run this job")
         # No job was submitted
         job_names = [instance1.job_model.name, instance2.job_model.name]
         self.assertFalse(JobResult.objects.filter(name__in=job_names).exists())
@@ -2085,9 +2028,7 @@ class ApprovalQueueTestCase(
         for user in (user1, user2):
             self.client.force_login(user)
             response = self.client.post(self._get_url("view", instance), data)
-            self.assertHttpStatus(response, 200, msg=str(user))
-            response_body = extract_page_body(response.content.decode(response.charset))
-            self.assertIn("You do not have permission", response_body, msg=str(user))
+            self.assertBodyContains(response, "You do not have permission")
             # Request was not deleted
             self.assertEqual(1, len(ScheduledJob.objects.filter(pk=instance.pk)), msg=str(user))
 
@@ -2120,9 +2061,7 @@ class ApprovalQueueTestCase(
         # Check object-based permissions are enforced for a different instance
         instance = self._get_queryset().first()
         response = self.client.post(self._get_url("view", instance), data)
-        self.assertHttpStatus(response, 200, msg=str(user))
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn("You do not have permission", response_body, msg=str(user))
+        self.assertBodyContains(response, "You do not have permission")
         # Request was not deleted
         self.assertEqual(1, len(ScheduledJob.objects.filter(pk=instance.pk)), msg=str(user))
 
@@ -2134,9 +2073,7 @@ class ApprovalQueueTestCase(
         data = {"_approve": True}
 
         response = self.client.post(self._get_url("view", instance), data)
-        self.assertHttpStatus(response, 200)
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn("You cannot approve your own job request", response_body)
+        self.assertBodyContains(response, "You cannot approve your own job request")
         # Job was not approved
         instance.refresh_from_db()
         self.assertIsNone(instance.approved_by_user)
@@ -2171,9 +2108,7 @@ class ApprovalQueueTestCase(
         for user in (user1, user2):
             self.client.force_login(user)
             response = self.client.post(self._get_url("view", instance), data)
-            self.assertHttpStatus(response, 200, msg=str(user))
-            response_body = extract_page_body(response.content.decode(response.charset))
-            self.assertIn("You do not have permission", response_body, msg=str(user))
+            self.assertBodyContains(response, "You do not have permission")
             # Job was not approved
             instance.refresh_from_db()
             self.assertIsNone(instance.approved_by_user)
@@ -2208,9 +2143,7 @@ class ApprovalQueueTestCase(
         # Check object-based permissions are enforced for a different instance
         instance = self._get_queryset().last()
         response = self.client.post(self._get_url("view", instance), data)
-        self.assertHttpStatus(response, 200, msg=str(user))
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn("You do not have permission", response_body, msg=str(user))
+        self.assertBodyContains(response, "You do not have permission")
         # Job was not scheduled
         instance.refresh_from_db()
         self.assertIsNone(instance.approved_by_user)
@@ -2251,9 +2184,7 @@ class JobResultTestCase(
         url = reverse("extras:jobresult_log-table", kwargs={"pk": JobResult.objects.first().pk})
         self.add_permissions("extras.view_jobresult", "extras.view_joblogentry")
         response = self.client.get(url)
-        self.assertHttpStatus(response, 200)
-        response_body = response.content.decode(response.charset)
-        self.assertIn("This is a test", response_body)
+        self.assertBodyContains(response, "This is a test")
 
     # TODO test with constrained permissions on both JobResult and JobLogEntry records
 
@@ -2394,18 +2325,18 @@ class JobTestCase(
         # Try delete with delete job permission
         self.add_permissions("extras.delete_job")
         response = self.client.post(**request, follow=True)
-        self.assertHttpStatus(response, 403)
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn(f"Unable to delete Job {instance}. System Job cannot be deleted", response_body)
+        self.assertBodyContains(
+            response, f"Unable to delete Job {instance}. System Job cannot be deleted", status_code=403
+        )
         # assert Job still exists
         self.assertTrue(self._get_queryset().filter(name=job_name).exists())
 
         # Try delete as a superuser
         self.user.is_superuser = True
         response = self.client.post(**request, follow=True)
-        self.assertHttpStatus(response, 403)
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn(f"Unable to delete Job {instance}. System Job cannot be deleted", response_body)
+        self.assertBodyContains(
+            response, f"Unable to delete Job {instance}. System Job cannot be deleted", status_code=403
+        )
         # assert Job still exists
         self.assertTrue(self._get_queryset().filter(name=job_name).exists())
 
@@ -2421,22 +2352,22 @@ class JobTestCase(
         # Try bulk delete with delete job permission
         self.add_permissions("extras.delete_job")
         response = self.client.post(self._get_url("bulk_delete"), data, follow=True)
-        self.assertHttpStatus(response, 403)
-        self.assertEqual(self._get_queryset().count(), initial_count)
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn(
-            f"Unable to delete Job {system_job_queryset.first()}. System Job cannot be deleted", response_body
+        self.assertBodyContains(
+            response,
+            f"Unable to delete Job {system_job_queryset.first()}. System Job cannot be deleted",
+            status_code=403,
         )
+        self.assertEqual(self._get_queryset().count(), initial_count)
 
         # Try bulk delete as a superuser
         self.user.is_superuser = True
         response = self.client.post(self._get_url("bulk_delete"), data, follow=True)
-        self.assertHttpStatus(response, 403)
-        self.assertEqual(self._get_queryset().count(), initial_count)
-        response_body = extract_page_body(response.content.decode(response.charset))
-        self.assertIn(
-            f"Unable to delete Job {system_job_queryset.first()}. System Job cannot be deleted", response_body
+        self.assertBodyContains(
+            response,
+            f"Unable to delete Job {system_job_queryset.first()}. System Job cannot be deleted",
+            status_code=403,
         )
+        self.assertEqual(self._get_queryset().count(), initial_count)
 
     def validate_job_data_after_bulk_edit(self, pk_list, old_data):
         # Name is bulk-editable
@@ -2502,10 +2433,7 @@ class JobTestCase(
         self.add_permissions("extras.run_job")
         for run_url in self.run_urls:
             response = self.client.get(run_url)
-            self.assertHttpStatus(response, 200, msg=run_url)
-
-            response_body = extract_page_body(response.content.decode(response.charset))
-            self.assertIn("TestPass", response_body)
+            self.assertBodyContains(response, "TestPass")
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
     def test_get_run_with_constrained_permission(self):
@@ -2548,10 +2476,7 @@ class JobTestCase(
 
         for run_url in self.run_urls:
             response = self.client.post(run_url, self.data_run_immediately)
-            self.assertHttpStatus(response, 200, msg=run_url)
-
-            content = extract_page_body(response.content.decode(response.charset))
-            self.assertIn("Celery worker process not running.", content)
+            self.assertBodyContains(response, "Celery worker process not running.")
 
     @mock.patch("nautobot.extras.views.get_worker_count", return_value=1)
     def test_run_now(self, _):
@@ -2598,9 +2523,7 @@ class JobTestCase(
             reverse("extras:job_run", kwargs={"pk": self.test_not_installed.pk}),
         ):
             response = self.client.post(run_url, self.data_run_immediately)
-            self.assertEqual(response.status_code, 200, msg=run_url)
-            response_body = extract_page_body(response.content.decode(response.charset))
-            self.assertIn("Job is not presently installed", response_body)
+            self.assertBodyContains(response, "Job is not presently installed")
 
             self.assertFalse(JobResult.objects.filter(name=self.test_not_installed.name).exists())
 
@@ -2613,9 +2536,7 @@ class JobTestCase(
             reverse("extras:job_run", kwargs={"pk": Job.objects.get(job_class_name="TestFail").pk}),
         ):
             response = self.client.post(run_url, self.data_run_immediately)
-            self.assertEqual(response.status_code, 200, msg=run_url)
-            response_body = extract_page_body(response.content.decode(response.charset))
-            self.assertIn("Job is not enabled to be run", response_body)
+            self.assertBodyContains(response, "Job is not enabled to be run")
             self.assertFalse(JobResult.objects.filter(name="fail.TestFail").exists())
 
     def test_run_now_missing_args(self):
@@ -2773,10 +2694,7 @@ class JobTestCase(
         for i, run_url in enumerate(self.run_urls):
             data["_schedule_name"] = f"test {i}"
             response = self.client.post(run_url, data)
-            self.assertHttpStatus(response, 200, msg=self.run_urls[1])
-
-            content = extract_page_body(response.content.decode(response.charset))
-            self.assertIn("Unable to schedule job: Job may have sensitive input variables.", content)
+            self.assertBodyContains(response, "Unable to schedule job: Job may have sensitive input variables.")
 
     @mock.patch("nautobot.extras.views.get_worker_count", return_value=1)
     def test_run_job_with_invalid_task_queue(self, _):
@@ -2817,31 +2735,28 @@ class JobTestCase(
         for run_url in self.run_urls:
             # Assert warning message shows in get
             response = self.client.get(run_url)
-            content = extract_page_body(response.content.decode(response.charset))
-            self.assertIn(
+            self.assertBodyContains(
+                response,
                 "This job is flagged as possibly having sensitive variables but is also flagged as requiring approval.",
-                content,
             )
 
             # Assert run button is disabled
-            self.assertInHTML(
+            self.assertBodyContains(
+                response,
                 """
                 <button type="submit" name="_run" id="id__run" class="btn btn-primary" disabled="disabled">
                     <i class="mdi mdi-play"></i> Run Job Now
                 </button>
                 """,
-                content,
+                html=True,
             )
             # Assert error message shows after post
             response = self.client.post(run_url, data)
-            self.assertHttpStatus(response, 200, msg=self.run_urls[1])
-
-            content = extract_page_body(response.content.decode(response.charset))
-            self.assertIn(
+            self.assertBodyContains(
+                response,
                 "Unable to run or schedule job: "
                 "This job is flagged as possibly having sensitive variables but is also flagged as requiring approval."
                 "One of these two flags must be removed before this job can be scheduled or run.",
-                content,
             )
 
     def test_job_object_change_log_view(self):
@@ -2849,10 +2764,7 @@ class JobTestCase(
         instance = self.test_pass
         self.add_permissions("extras.view_objectchange", "extras.view_job")
         response = self.client.get(instance.get_changelog_url())
-        content = extract_page_body(response.content.decode(response.charset))
-
-        self.assertHttpStatus(response, 200)
-        self.assertIn(f"{instance.name} - Change Log", content)
+        self.assertBodyContains(response, f"{instance.name} - Change Log")
 
 
 class JobButtonTestCase(
@@ -2949,10 +2861,8 @@ class JobButtonRenderingTestCase(TestCase):
     def test_view_object_with_job_button(self):
         """Ensure that the job button is rendered."""
         response = self.client.get(self.location_type.get_absolute_url(), follow=True)
-        self.assertEqual(response.status_code, 200)
-        content = extract_page_body(response.content.decode(response.charset))
-        self.assertIn(f"JobButton {self.location_type.name}", content, content)
-        self.assertIn("Click me!", content, content)
+        self.assertBodyContains(response, f"JobButton {self.location_type.name}")
+        self.assertBodyContains(response, "Click me!")
 
     def test_task_queue_hidden_input_is_present(self):
         """
@@ -2962,16 +2872,12 @@ class JobButtonRenderingTestCase(TestCase):
         self.job.task_queues = ["overriden_queue", "default", "priority"]
         self.job.save()
         response = self.client.get(self.location_type.get_absolute_url(), follow=True)
-        self.assertEqual(response.status_code, 200)
-        content = extract_page_body(response.content.decode(response.charset))
-        self.assertIn(f'<input type="hidden" name="_task_queue" value="{self.job.task_queues[0]}">', content, content)
+        self.assertBodyContains(response, f'<input type="hidden" name="_task_queue" value="{self.job.task_queues[0]}">')
         self.job.task_queues_override = False
         self.job.save()
         response = self.client.get(self.location_type.get_absolute_url(), follow=True)
-        self.assertEqual(response.status_code, 200)
-        content = extract_page_body(response.content.decode(response.charset))
-        self.assertIn(
-            f'<input type="hidden" name="_task_queue" value="{settings.CELERY_TASK_DEFAULT_QUEUE}">', content, content
+        self.assertBodyContains(
+            response, f'<input type="hidden" name="_task_queue" value="{settings.CELERY_TASK_DEFAULT_QUEUE}">'
         )
 
     def test_view_object_with_unsafe_text(self):
@@ -3426,7 +3332,6 @@ class RelationshipAssociationTestCase(
         response = self.client.get(self._get_url("list"))
         self.assertHttpStatus(response, 200)
         content = 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(instance1.source.name, content, msg=content)
         self.assertIn(instance1.destination.name, content, msg=content)
         self.assertNotIn(instance2.source.name, content, msg=content)
@@ -3470,10 +3375,7 @@ class StaticGroupAssociationTestCase(
 
         self.add_permissions("extras.view_staticgroupassociation")
         response = self.client.get(f"{self._get_url('list')}?dynamic_group={sga1.dynamic_group.pk}")
-        self.assertHttpStatus(response, 200)
-        content = extract_page_body(response.content.decode(response.charset))
-
-        self.assertIn(sga1.get_absolute_url(), content, msg=content)
+        self.assertBodyContains(response, sga1.get_absolute_url())
 
 
 class StatusTestCase(
@@ -3610,7 +3512,7 @@ class TagTestCase(ViewTestCases.OrganizationalObjectViewTestCase):
         response = self.client.post(**request)
         tag = Tag.objects.filter(name=self.form_data["name"])
         self.assertFalse(tag.exists())
-        self.assertIn("content_types: Select a valid choice", str(response.content))
+        self.assertBodyContains(response, "content_types: Select a valid choice")
 
     def test_update_tags_remove_content_type(self):
         """Test removing a tag content_type that is been tagged to a model"""

nautobot/extras/utils.py

@@ -21,7 +21,7 @@ from nautobot.core.choices import ColorChoices
 from nautobot.core.constants import CHARFIELD_MAX_LENGTH
 from nautobot.core.models.managers import TagsManager
 from nautobot.core.models.utils import find_models_with_matching_fields
-from nautobot.extras.choices import ObjectChangeActionChoices
+from nautobot.extras.choices import DynamicGroupTypeChoices, ObjectChangeActionChoices
 from nautobot.extras.constants import (
     CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL,
     EXTRAS_FEATURES,
@@ -366,17 +366,30 @@ def get_celery_queues():
     """
     from nautobot.core.celery import app  # prevent circular import
 
-    celery_queues = {}
+    celery_queues = None
+    with contextlib.suppress(redis.exceptions.ConnectionError):
+        celery_queues = cache.get("nautobot.extras.utils.get_celery_queues")
 
-    celery_inspect = app.control.inspect()
-    active_queues = celery_inspect.active_queues()
-    if active_queues is None:
-        return celery_queues
-    for task_queue_list in active_queues.values():
-        distinct_queues = {q["name"] for q in task_queue_list}
-        for queue in distinct_queues:
-            celery_queues.setdefault(queue, 0)
-            celery_queues[queue] += 1
+    if celery_queues is None:
+        celery_queues = {}
+        celery_inspect = app.control.inspect()
+        try:
+            active_queues = celery_inspect.active_queues()
+        except redis.exceptions.ConnectionError:
+            # Celery seems to be not smart enough to auto-retry on intermittent failures, so let's do it ourselves:
+            try:
+                active_queues = celery_inspect.active_queues()
+            except redis.exceptions.ConnectionError as err:
+                logger.error("Repeated ConnectionError from Celery/Redis: %s", err)
+                active_queues = None
+        if active_queues is None:
+            return celery_queues
+        for task_queue_list in active_queues.values():
+            distinct_queues = {q["name"] for q in task_queue_list}
+            for queue in distinct_queues:
+                celery_queues[queue] = celery_queues.get(queue, 0) + 1
+        with contextlib.suppress(redis.exceptions.ConnectionError):
+            cache.set("nautobot.extras.utils.get_celery_queues", celery_queues, timeout=5)
 
     return celery_queues
 
@@ -584,6 +597,32 @@ def fixup_null_statuses(*, model, model_contenttype, status_model):
         print(f"    Found and fixed {updated_count} instances of {model.__name__} that had null 'status' fields.")
 
 
+def fixup_dynamic_group_group_types(apps, *args, **kwargs):  # pylint: disable=redefined-outer-name
+    """Set dynamic group group_type values correctly."""
+    DynamicGroup = apps.get_model("extras", "DynamicGroup")
+    DynamicGroupMembership = apps.get_model("extras", "DynamicGroupMembership")
+    count_1 = count_2 = 0
+    # See note in migration 0112 - for some reason, if we were to do the "intuitive" thing, and call
+    # `DynamicGroup.objects.filter(children__isnull=False)`, we would unexpectedly get those groups for which their
+    # *parent* is non-null. The below is an alternate approach that should remain correct even if that issue gets fixed.
+    parent_group_names = set(DynamicGroupMembership.objects.values_list("parent_group__name", flat=True))
+    parent_groups_with_wrong_type = DynamicGroup.objects.filter(name__in=parent_group_names).exclude(
+        group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_SET
+    )
+    if parent_groups_with_wrong_type.exists():
+        count_1 = parent_groups_with_wrong_type.update(group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_SET)
+        print(f'\n    Found and fixed {count_1} DynamicGroup(s) that should be typed as "Group of groups".')
+
+    filter_groups_with_wrong_type = DynamicGroup.objects.exclude(filter__exact={}).exclude(
+        group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_FILTER
+    )
+    if filter_groups_with_wrong_type.exists():
+        count_2 = filter_groups_with_wrong_type.update(group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_FILTER)
+        print(f'\n    Found and fixed {count_2} DynamicGroup(s) that should be typed as "Filter-defined".')
+
+    return count_1, count_2
+
+
 def migrate_role_data(
     model_to_migrate,
     *,

nautobot/ipam/tests/test_api.py

@@ -200,14 +200,19 @@ class VRFDeviceAssignmentTest(APIViewTestCases.APIViewTestCase):
         }
         self.add_permissions("ipam.add_vrfdeviceassignment")
         response = self.client.post(self._get_list_url(), duplicate_device_create_data, format="json", **self.header)
-        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("The fields device, vrf must make a unique set.", str(response.content))
+        self.assertContains(
+            response, "The fields device, vrf must make a unique set.", status_code=status.HTTP_400_BAD_REQUEST
+        )
         response = self.client.post(self._get_list_url(), duplicate_vm_create_data, format="json", **self.header)
-        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("The fields virtual_machine, vrf must make a unique set.", str(response.content))
+        self.assertContains(
+            response, "The fields virtual_machine, vrf must make a unique set.", status_code=status.HTTP_400_BAD_REQUEST
+        )
         response = self.client.post(self._get_list_url(), invalid_create_data, format="json", **self.header)
-        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("A VRF cannot be associated with both a device and a virtual machine.", str(response.content))
+        self.assertContains(
+            response,
+            "A VRF cannot be associated with both a device and a virtual machine.",
+            status_code=status.HTTP_400_BAD_REQUEST,
+        )
 
 
 class VRFPrefixAssignmentTest(APIViewTestCases.APIViewTestCase):
@@ -266,14 +271,15 @@ class VRFPrefixAssignmentTest(APIViewTestCases.APIViewTestCase):
         }
         self.add_permissions("ipam.add_vrfprefixassignment")
         response = self.client.post(self._get_list_url(), duplicate_create_data, format="json", **self.header)
-        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("The fields vrf, prefix must make a unique set.", str(response.content))
+        self.assertContains(
+            response, "The fields vrf, prefix must make a unique set.", status_code=status.HTTP_400_BAD_REQUEST
+        )
         response = self.client.post(self._get_list_url(), wrong_namespace_create_data, format="json", **self.header)
-        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("Prefix must be in same namespace as VRF", str(response.content))
+        self.assertContains(
+            response, "Prefix must be in same namespace as VRF", status_code=status.HTTP_400_BAD_REQUEST
+        )
         response = self.client.post(self._get_list_url(), missing_field_create_data, format="json", **self.header)
-        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("This field may not be null.", str(response.content))
+        self.assertContains(response, "This field may not be null.", status_code=status.HTTP_400_BAD_REQUEST)
 
 
 class RouteTargetTest(APIViewTestCases.APIViewTestCase):