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

nautobot/dcim/tests/test_views.py

@@ -284,9 +284,7 @@ class LocationTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "data": post_data(test_form_data),
         }
         response = self.client.post(**request)
-        self.assertHttpStatus(response, 200)
-        response_body = response.content.decode(response.charset)
-        self.assertIn("“Generic Site” is not a valid UUID.", response_body)
+        self.assertBodyContains(response, "“Generic Site” is not a valid UUID.")
         test_form_data["parent"] = site_1.pk
         request["data"] = post_data(test_form_data)
         self.assertHttpStatus(self.client.post(**request), 302)
@@ -1172,8 +1170,7 @@ module-bays:
         }
 
         response = self.client.post(url, data)
-        self.assertHttpStatus(response, 200)
-        self.assertIn("failed validation", response.content.decode(response.charset))
+        self.assertBodyContains(response, "failed validation")
 
 
 class ModuleTypeTestCase(
@@ -2279,12 +2276,8 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
 
         url = reverse("dcim:device_interfaces", kwargs={"pk": device.pk})
         response = self.client.get(url)
-        self.assertHttpStatus(response, 200)
-        response_body = response.content.decode(response.charset)
-        # Count the number of occurrences of "Add IP address" in the response_body
-        count = response_body.count("Add IP address")
         # Assert that "Add IP address" appears for each of the three interfaces
-        self.assertEqual(count, 3)
+        self.assertBodyContains(response, "Add IP address", count=3)
 
     def test_device_interface_assign_ipaddress(self):
         device = Device.objects.first()
@@ -2322,29 +2315,19 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "data": post_data(assign_ip_form_data),
         }
 
-        with self.subTest("Assert Cannnot assign IPAddress('Add New') without permission"):
+        with self.subTest("Assert Cannot assign IPAddress('Add New') without permission"):
             # Assert Add new IPAddress
             response = self.client.post(**add_new_ip_request, follow=True)
-            response_body = response.content.decode(response.charset)
-            self.assertHttpStatus(response, 200)
+            self.assertBodyContains(response, f"Interface with id "{self.interfaces[0].pk}" not found")
             self.interfaces[0].refresh_from_db()
             self.assertEqual(self.interfaces[0].ip_addresses.all().count(), 0)
-            self.assertIn(
-                f"Interface with id "{self.interfaces[0].pk}" not found",
-                response_body,
-            )
 
-        with self.subTest("Assert Cannnot assign IPAddress(Exsisting IP) without permission"):
+        with self.subTest("Assert Cannot assign IPAddress(Existing IP) without permission"):
             # Assert Assign Exsisting IPAddress
             response = self.client.post(**assign_ip_request, follow=True)
-            response_body = response.content.decode(response.charset)
-            self.assertHttpStatus(response, 200)
+            self.assertBodyContains(response, f"Interface with id "{self.interfaces[1].pk}" not found")
             self.interfaces[1].refresh_from_db()
             self.assertEqual(self.interfaces[1].ip_addresses.all().count(), 0)
-            self.assertIn(
-                f"Interface with id "{self.interfaces[1].pk}" not found",
-                response_body,
-            )
 
         self.add_permissions("dcim.change_interface", "ipam.view_ipaddress")
 
@@ -2375,10 +2358,7 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
                 "data": post_data(assign_ip_form_data),
             }
             response = self.client.post(**assign_ip_request, follow=True)
-            self.assertHttpStatus(response, 200)
-            self.assertIn(
-                "Please select at least one IP Address from the table.", response.content.decode(response.charset)
-            )
+            self.assertBodyContains(response, "Please select at least one IP Address from the table.")
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_device_rearports(self):
@@ -2683,12 +2663,8 @@ class ModuleTestCase(ViewTestCases.PrimaryObjectViewTestCase):
 
         url = reverse("dcim:module_interfaces", kwargs={"pk": module.pk})
         response = self.client.get(url)
-        self.assertHttpStatus(response, 200)
-        response_body = response.content.decode(response.charset)
-        # Count the number of occurrences of "Add IP address" in the response_body
-        count = response_body.count("Add IP address")
         # Assert that "Add IP address" appears for each of the three interfaces
-        self.assertEqual(count, 3)
+        self.assertBodyContains(response, "Add IP address", count=3)
 
     def test_module_interface_assign_ipaddress(self):
         module = Module.objects.first()
@@ -2726,29 +2702,19 @@ class ModuleTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "data": post_data(assign_ip_form_data),
         }
 
-        with self.subTest("Assert Cannnot assign IPAddress('Add New') without permission"):
+        with self.subTest("Assert Cannot assign IPAddress('Add New') without permission"):
             # Assert Add new IPAddress
             response = self.client.post(**add_new_ip_request, follow=True)
-            response_body = response.content.decode(response.charset)
-            self.assertHttpStatus(response, 200)
+            self.assertBodyContains(response, f"Interface with id "{self.interfaces[0].pk}" not found")
             self.interfaces[0].refresh_from_db()
             self.assertEqual(self.interfaces[0].ip_addresses.all().count(), 0)
-            self.assertIn(
-                f"Interface with id "{self.interfaces[0].pk}" not found",
-                response_body,
-            )
 
-        with self.subTest("Assert Cannnot assign IPAddress(Exsisting IP) without permission"):
+        with self.subTest("Assert Cannot assign IPAddress(Existing IP) without permission"):
             # Assert Assign Exsisting IPAddress
             response = self.client.post(**assign_ip_request, follow=True)
-            response_body = response.content.decode(response.charset)
-            self.assertHttpStatus(response, 200)
+            self.assertBodyContains(response, f"Interface with id "{self.interfaces[1].pk}" not found")
             self.interfaces[1].refresh_from_db()
             self.assertEqual(self.interfaces[1].ip_addresses.all().count(), 0)
-            self.assertIn(
-                f"Interface with id "{self.interfaces[1].pk}" not found",
-                response_body,
-            )
 
         self.add_permissions("dcim.change_interface", "ipam.view_ipaddress")
 
@@ -3228,8 +3194,8 @@ class InterfaceTestCase(ViewTestCases.DeviceComponentViewTestCase):
         invalid_ipaddress_link = reverse("ipam:ipaddress_edit", args=(ipaddress.pk,))
         valid_ipaddress_link = ipaddress.get_absolute_url()
         response = self.client.get(interface.get_absolute_url() + "?tab=main")
-        response_content = response.content.decode(response.charset)
-        self.assertIn(valid_ipaddress_link, response_content)
+        self.assertBodyContains(response, valid_ipaddress_link)
+        response_content = extract_page_body(response.content.decode(response.charset))
         self.assertNotIn(invalid_ipaddress_link, response_content)
 
 
@@ -4113,7 +4079,6 @@ class InterfaceConnectionsTestCase(ViewTestCases.ListObjectsViewTestCase):
         response = self.client.get(f"{self._get_url('list')}?id={instance1.pk}")
         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
         if hasattr(self.model, "name"):
             self.assertIn(instance1.name, content, msg=content)
             self.assertNotIn(instance2.name, content, msg=content)
@@ -4209,11 +4174,11 @@ class VirtualChassisTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         Interface.objects.create(device=self.devices[2], name="device 2 interface 1", status=interface_status)
         Interface.objects.create(device=self.devices[2], name="device 2 interface 2", status=interface_status)
         response = self.client.get(reverse("dcim:device_interfaces", kwargs={"pk": self.devices[0].pk}))
-        self.assertIn('Interfaces <span class="badge">6</span>', str(response.content))
-        self.assertIn("device 1 interface 1", str(response.content))
-        self.assertIn("device 1 interface 2", str(response.content))
-        self.assertIn("device 2 interface 1", str(response.content))
-        self.assertIn("device 2 interface 2", str(response.content))
+        self.assertBodyContains(response, 'Interfaces <span class="badge">6</span>')
+        self.assertBodyContains(response, "device 1 interface 1")
+        self.assertBodyContains(response, "device 1 interface 2")
+        self.assertBodyContains(response, "device 2 interface 1")
+        self.assertBodyContains(response, "device 2 interface 2")
 
     def test_device_column_visible(self):
         """
@@ -4226,7 +4191,7 @@ class VirtualChassisTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         Interface.objects.create(device=self.devices[0], name="eth0", status=interface_status)
         Interface.objects.create(device=self.devices[0], name="eth1", status=interface_status)
         response = self.client.get(reverse("dcim:device_interfaces", kwargs={"pk": self.devices[0].pk}))
-        self.assertIn("<th >Device</th>", str(response.content))
+        self.assertBodyContains(response, "<th>Device</th>", html=True)
 
     def test_device_column_not_visible(self):
         """
@@ -4239,9 +4204,9 @@ class VirtualChassisTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         Interface.objects.create(device=self.devices[1], name="eth2", status=interface_status)
         Interface.objects.create(device=self.devices[1], name="eth3", status=interface_status)
         response = self.client.get(reverse("dcim:device_interfaces", kwargs={"pk": self.devices[1].pk}))
-        self.assertNotIn("<th >Device</th>", str(response.content))
+        self.assertNotIn("<th >Device</th>", extract_page_body(response.content.decode(response.charset)))
         # Sanity check:
-        self.assertIn("<th >Name</th>", str(response.content))
+        self.assertBodyContains(response, "<th>Name</th>", html=True)
 
 
 class PowerPanelTestCase(ViewTestCases.PrimaryObjectViewTestCase):
@@ -4408,9 +4373,7 @@ class PathTraceViewTestCase(ModelViewTestCase):
         url = reverse("dcim:rearport_trace", args=[obj.pk])
         cablepath_id = CablePath.objects.first().id
         response = self.client.get(url + f"?cablepath_id={cablepath_id}")
-        self.assertHttpStatus(response, 200)
-        content = extract_page_body(response.content.decode(response.charset))
-        self.assertInHTML("<h1>Cable Trace for Rear Port Rear Port 1</h1>", content)
+        self.assertBodyContains(response, "<h1>Cable Trace for Rear Port Rear Port 1</h1>", html=True)
 
 
 class DeviceRedundancyGroupTestCase(ViewTestCases.PrimaryObjectViewTestCase):
@@ -4621,10 +4584,8 @@ class SoftwareImageFileTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "_confirm": True,  # Form button
         }
         response = self.client.post(self._get_url("bulk_delete"), data, follow=True)
-        self.assertHttpStatus(response, 200)
-        response_body = response.content.decode(response.charset)
         # Assert protected error message included in the response body
-        self.assertInHTML(f"<span>{device_type_to_software_image_file}</span>", response_body)
+        self.assertBodyContains(response, f"<span>{device_type_to_software_image_file}</span>", html=True)
 
 
 class SoftwareVersionTestCase(ViewTestCases.PrimaryObjectViewTestCase):
@@ -4701,10 +4662,8 @@ class SoftwareVersionTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "_confirm": True,  # Form button
         }
         response = self.client.post(self._get_url("bulk_delete"), data, follow=True)
-        self.assertHttpStatus(response, 200)
-        response_body = response.content.decode(response.charset)
         # Assert protected error message included in the response body
-        self.assertInHTML(f"<span>{device_type_to_software_image_file}</span>", response_body)
+        self.assertBodyContains(response, f"<span>{device_type_to_software_image_file}</span>", html=True)
 
 
 class ControllerTestCase(ViewTestCases.PrimaryObjectViewTestCase):

nautobot/extras/datasources/git.py

@@ -177,7 +177,12 @@ def ensure_git_repository(repository_record, logger=None, head=None):  # pylint:
     if logger:
         if changed:
             logger.info("Repository successfully refreshed")
-        logger.info(f'The current Git repository hash is "{repository_record.current_head}"')
+        logger.info(
+            '%s: the current Git repository hash is "%s"',
+            repository_record.name,
+            repository_record.current_head,
+            extra={"object": repository_record},
+        )
 
     return changed
 

nautobot/extras/migrations/0112_dynamic_group_group_type_data_migration.py

@@ -10,6 +10,9 @@ def set_dynamic_group_group_types(apps, schema_editor):
     # The group_type field defaults to TYPE_DYNAMIC_FILTER
     # There are no preexisting TYPE_STATIC groups as that's a new feature
     # Any group that has children should be converted to TYPE_DYNAMIC_SET
+    # NOTE: The below is actually incorrect (see migration 0116) as for some reason, during migrations ONLY,
+    # Django somehow swaps the `parent` and `children` relations on DynamicGroup such that the below actually detects
+    # the opposite set of groups from what would be expected.
     DynamicGroup.objects.filter(children__isnull=False).distinct().update(
         group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_SET
     )

nautobot/extras/migrations/0116_fix_dynamic_group_group_type_data_migration.py

@@ -0,0 +1,16 @@
+from django.db import migrations
+
+from nautobot.extras.utils import fixup_dynamic_group_group_types
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("extras", "0115_scheduledjob_time_zone"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            code=fixup_dynamic_group_group_types,
+            reverse_code=migrations.operations.special.RunPython.noop,
+        ),
+    ]

nautobot/extras/tests/test_customfields.py

@@ -15,7 +15,7 @@ from nautobot.core.models.fields import slugify_dashes_to_underscores
 from nautobot.core.tables import CustomFieldColumn
 from nautobot.core.testing import APITestCase, TestCase, TransactionTestCase
 from nautobot.core.testing.models import ModelTestCases
-from nautobot.core.testing.utils import post_data
+from nautobot.core.testing.utils import extract_page_body, post_data
 from nautobot.core.utils.lookup import get_changes_for_model
 from nautobot.dcim.filters import LocationFilterSet
 from nautobot.dcim.forms import RackFilterForm
@@ -995,18 +995,15 @@ class CustomFieldDataAPITest(APITestCase):
             },
         }
         response = self.client.post(self.list_url, data, format="json", **self.header)
-        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("Value must be a string", str(response.content))
+        self.assertContains(response, "Value must be a string", status_code=status.HTTP_400_BAD_REQUEST)
 
         data["custom_fields"].update({self.cf_text.key: 2})
         response = self.client.post(self.list_url, data, format="json", **self.header)
-        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("Value must be a string", str(response.content))
+        self.assertContains(response, "Value must be a string", status_code=status.HTTP_400_BAD_REQUEST)
 
         data["custom_fields"].update({self.cf_text.key: True})
         response = self.client.post(self.list_url, data, format="json", **self.header)
-        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("Value must be a string", str(response.content))
+        self.assertContains(response, "Value must be a string", status_code=status.HTTP_400_BAD_REQUEST)
 
     def test_create_without_required_field(self):
         self.cf_text.default = None
@@ -1019,8 +1016,7 @@ class CustomFieldDataAPITest(APITestCase):
             "status": self.statuses[0].pk,
         }
         response = self.client.post(self.list_url, data, format="json", **self.header)
-        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("Required field cannot be empty", str(response.content))
+        self.assertContains(response, "Required field cannot be empty", status_code=status.HTTP_400_BAD_REQUEST)
 
         # Try in CSV format too
         csvdata = "\n".join(
@@ -1030,8 +1026,7 @@ class CustomFieldDataAPITest(APITestCase):
             ]
         )
         response = self.client.post(self.list_url, csvdata, content_type="text/csv", **self.header)
-        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("Required field cannot be empty", str(response.content))
+        self.assertContains(response, "Required field cannot be empty", status_code=status.HTTP_400_BAD_REQUEST)
 
     def test_create_invalid_select_choice(self):
         data = {
@@ -1043,8 +1038,7 @@ class CustomFieldDataAPITest(APITestCase):
             },
         }
         response = self.client.post(self.list_url, data, format="json", **self.header)
-        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("Invalid choice", str(response.content))
+        self.assertContains(response, "Invalid choice", status_code=status.HTTP_400_BAD_REQUEST)
 
         # Try in CSV format too
         csvdata = "\n".join(
@@ -1054,8 +1048,7 @@ class CustomFieldDataAPITest(APITestCase):
             ]
         )
         response = self.client.post(self.list_url, csvdata, content_type="text/csv", **self.header)
-        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("Invalid choice", str(response.content))
+        self.assertContains(response, "Invalid choice", status_code=status.HTTP_400_BAD_REQUEST)
 
 
 class CustomFieldImportTest(TestCase):
@@ -1157,7 +1150,7 @@ class CustomFieldImportTest(TestCase):
         try:
             location1 = Location.objects.get(name="Location 1")
         except Location.DoesNotExist:
-            self.fail(str(response.content))
+            self.fail(extract_page_body(response.content.decode(response.charset)))
         self.assertEqual(len(location1.cf), 8)
         self.assertEqual(location1.cf["text"], "ABC")
         self.assertEqual(location1.cf["integer"], 123)

nautobot/extras/tests/test_dynamicgroups.py

@@ -1,5 +1,6 @@
 import random
 
+from django.apps import apps
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.db.models import ProtectedError, QuerySet
@@ -40,6 +41,7 @@ from nautobot.extras.models import (
     Status,
     Tag,
 )
+from nautobot.extras.utils import fixup_dynamic_group_group_types
 from nautobot.ipam.models import IPAddress, Prefix
 from nautobot.ipam.querysets import PrefixQuerySet
 from nautobot.tenancy.models import Tenant
@@ -1224,3 +1226,117 @@ class DynamicGroupMembershipFilterTest(DynamicGroupTestBase, FilterTestCases.Fil
         for value, cnt in tests.items():
             params = {"q": value}
             self.assertEqual(self.filterset(params, self.queryset).qs.count(), cnt)
+
+
+class DynamicGroupFixupTestCase(TestCase):
+    """Check for the correct functioning of the fixup_dynamic_group_group_types() data migration helper function."""
+
+    def test_fixup_dynamic_group_group_types(self):
+        device_ct = ContentType.objects.get_for_model(Device)
+
+        good_grandparent_group = DynamicGroup.objects.create(
+            name="Good Grandparent",
+            group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_SET,
+            content_type=device_ct,
+        )
+        bad_grandparent_group = DynamicGroup.objects.create(
+            name="Bad Grandparent",
+            group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_FILTER,  # wrong, but possible due to #6329
+            content_type=device_ct,
+        )
+        good_parent_group = DynamicGroup.objects.create(
+            name="Good Parent",
+            group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_SET,
+            content_type=device_ct,
+        )
+        bad_parent_group = DynamicGroup.objects.create(
+            name="Bad Parent",
+            group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_FILTER,  # wrong, #6329 again
+            content_type=device_ct,
+        )
+        good_child_group = DynamicGroup.objects.create(
+            name="Good Child",
+            group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_FILTER,
+            content_type=device_ct,
+            filter={"status": [Status.objects.get_for_model(Device).first().name]},
+        )
+        bad_child_group = DynamicGroup.objects.create(
+            name="Bad Child",
+            group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_SET,  # wrong, #6329 again
+            content_type=device_ct,
+            filter={"status": [Status.objects.get_for_model(Device).first().name]},
+        )
+
+        DynamicGroupMembership.objects.create(
+            parent_group=good_grandparent_group,
+            group=good_parent_group,
+            weight=10,
+            operator=DynamicGroupOperatorChoices.OPERATOR_INTERSECTION,
+        )
+        DynamicGroupMembership.objects.create(
+            parent_group=bad_grandparent_group,
+            group=bad_parent_group,
+            weight=10,
+            operator=DynamicGroupOperatorChoices.OPERATOR_INTERSECTION,
+        )
+        DynamicGroupMembership.objects.create(
+            parent_group=good_parent_group,
+            group=good_child_group,
+            weight=10,
+            operator=DynamicGroupOperatorChoices.OPERATOR_INTERSECTION,
+        )
+        DynamicGroupMembership.objects.create(
+            parent_group=bad_parent_group,
+            group=bad_child_group,
+            weight=10,
+            operator=DynamicGroupOperatorChoices.OPERATOR_INTERSECTION,
+        )
+
+        good_standalone_group_1 = DynamicGroup.objects.create(
+            name="Good Standalone Group 1",
+            group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_FILTER,
+            content_type=device_ct,
+            # empty filter - this is OK!
+        )
+        good_standalone_group_2 = DynamicGroup.objects.create(
+            name="Good Standalone Group 2",
+            group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_SET,
+            content_type=device_ct,
+        )
+        bad_standalone_group = DynamicGroup.objects.create(
+            name="Bad Standalone Group",
+            group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_SET,
+            content_type=device_ct,
+            filter={"status": [Status.objects.get_for_model(Device).first().name]},
+        )
+
+        # DynamicGroupMembership.save() will actually auto-fixup the type on bad_parent_group and bad_grandparent_group.
+        # Make them wrong again:
+        bad_grandparent_group.group_type = DynamicGroupTypeChoices.TYPE_DYNAMIC_FILTER
+        bad_grandparent_group.save()
+        bad_parent_group.group_type = DynamicGroupTypeChoices.TYPE_DYNAMIC_FILTER
+        bad_parent_group.save()
+
+        count_1, count_2 = fixup_dynamic_group_group_types(apps)
+
+        self.assertEqual(count_1, 2)  # bad_grandparent_group, bad_parent_group
+        self.assertEqual(count_2, 2)  # bad_child_group, bad_standalone_group
+
+        good_grandparent_group.refresh_from_db()
+        self.assertEqual(good_grandparent_group.group_type, DynamicGroupTypeChoices.TYPE_DYNAMIC_SET)  # unchanged
+        bad_grandparent_group.refresh_from_db()
+        self.assertEqual(bad_grandparent_group.group_type, DynamicGroupTypeChoices.TYPE_DYNAMIC_SET)  # fixed
+        good_parent_group.refresh_from_db()
+        self.assertEqual(good_parent_group.group_type, DynamicGroupTypeChoices.TYPE_DYNAMIC_SET)  # unchanged
+        bad_parent_group.refresh_from_db()
+        self.assertEqual(bad_parent_group.group_type, DynamicGroupTypeChoices.TYPE_DYNAMIC_SET)  # fixed
+        good_child_group.refresh_from_db()
+        self.assertEqual(good_child_group.group_type, DynamicGroupTypeChoices.TYPE_DYNAMIC_FILTER)  # unchanged
+        bad_child_group.refresh_from_db()
+        self.assertEqual(bad_child_group.group_type, DynamicGroupTypeChoices.TYPE_DYNAMIC_FILTER)  # fixed
+        good_standalone_group_1.refresh_from_db()
+        self.assertEqual(good_standalone_group_1.group_type, DynamicGroupTypeChoices.TYPE_DYNAMIC_FILTER)  # unchanged
+        good_standalone_group_2.refresh_from_db()
+        self.assertEqual(good_standalone_group_2.group_type, DynamicGroupTypeChoices.TYPE_DYNAMIC_SET)  # unchanged
+        bad_standalone_group.refresh_from_db()
+        self.assertEqual(bad_standalone_group.group_type, DynamicGroupTypeChoices.TYPE_DYNAMIC_FILTER)  # fixed

nautobot/extras/tests/test_plugins.py

@@ -694,17 +694,15 @@ class TestAppCoreViewOverrides(TestCase):
 
     def test_views_are_overridden(self):
         response = self.client.get(reverse("plugins:example_app:view_to_be_overridden"))
-        self.assertEqual(b"Hello world! I'm an overridden view.", response.content)
+        self.assertEqual("Hello world! I'm an overridden view.", response.content.decode(response.charset))
 
         response = self.client.get(
             f'{reverse("plugins:plugin_detail", kwargs={"plugin": "example_app_with_view_override"})}'
         )
         self.assertIn(
-            (
-                b"plugins:example_app:view_to_be_overridden <code>"
-                b"example_app_with_view_override.views.ViewOverride</code>"
-            ),
-            response.content,
+            "plugins:example_app:view_to_be_overridden <code>"
+            "example_app_with_view_override.views.ViewOverride</code>",
+            extract_page_body(response.content.decode(response.charset)),
         )
 
 

nautobot/extras/tests/test_utils.py

@@ -1,5 +1,7 @@
 from unittest import mock
 
+from django.core.cache import cache
+
 from nautobot.core.testing import TestCase
 from nautobot.extras.registry import registry
 from nautobot.extras.utils import get_celery_queues, get_worker_count, populate_model_features_registry
@@ -17,6 +19,7 @@ class UtilsTestCase(TestCase):
             self.assertDictEqual(get_celery_queues(), {"queue1": 1})
 
         with self.subTest("2 workers 2 shared queues"):
+            cache.clear()
             mock_active_queues.return_value = {
                 "celery@worker1": [{"name": "queue1"}, {"name": "queue2"}],
                 "celery@worker2": [{"name": "queue1"}, {"name": "queue2"}],
@@ -24,6 +27,7 @@ class UtilsTestCase(TestCase):
             self.assertDictEqual(get_celery_queues(), {"queue1": 2, "queue2": 2})
 
         with self.subTest("2 workers 2 individual queues"):
+            cache.clear()
             mock_active_queues.return_value = {
                 "celery@worker1": [{"name": "queue1"}],
                 "celery@worker2": [{"name": "queue2"}],
@@ -31,6 +35,7 @@ class UtilsTestCase(TestCase):
             self.assertDictEqual(get_celery_queues(), {"queue1": 1, "queue2": 1})
 
         with self.subTest("2 workers 3 queues"):
+            cache.clear()
             mock_active_queues.return_value = {
                 "celery@worker1": [{"name": "queue1"}, {"name": "queue3"}],
                 "celery@worker2": [{"name": "queue2"}],