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

nautobot/dcim/forms.py

@@ -213,23 +213,27 @@ class InterfaceCommonForm(forms.Form):
         elif mode == InterfaceModeChoices.MODE_TAGGED_ALL:
             self.cleaned_data["tagged_vlans"] = []
 
-        # Validate tagged VLANs; must be a global VLAN or in the same location
-        # TODO: after Location model replaced Site, which was not a hierarchical model, should we allow users to add a VLAN
-        # belongs to the parent Location or the child location of the parent device to the `tagged_vlan` field of the interface?
+        # Validate tagged VLANs; must be a global VLAN or in the same location as the
+        # parent device/VM or any of that location's parent locations
         elif mode == InterfaceModeChoices.MODE_TAGGED:
-            valid_location = self.cleaned_data[parent_field].location
+            location = self.cleaned_data[parent_field].location
+            if location:
+                location_ids = location.ancestors(include_self=True).values_list("id", flat=True)
+            else:
+                location_ids = []
             invalid_vlans = [
                 str(v)
                 for v in tagged_vlans
                 if v.locations.without_tree_fields().exists()
-                and not VLANLocationAssignment.objects.filter(location=valid_location, vlan=v).exists()
+                and not VLANLocationAssignment.objects.filter(location__in=location_ids, vlan=v).exists()
             ]
 
             if invalid_vlans:
                 raise forms.ValidationError(
                     {
-                        "tagged_vlans": f"The tagged VLANs ({', '.join(invalid_vlans)}) must belong to the same location as "
-                        f"the interface's parent device/VM, or they must be global"
+                        "tagged_vlans": f"The tagged VLANs ({', '.join(invalid_vlans)}) must have the same location as the "
+                        "interface's parent device, or is in one of the parents of the interface's parent device's location, "
+                        "or it must be global."
                     }
                 )
 

nautobot/dcim/models/device_components.py

@@ -727,19 +727,22 @@ class Interface(ModularComponentModel, CableTermination, PathEndpoint, BaseInter
                     )
 
         # Validate untagged VLAN
-        # TODO: after Location model replaced Site, which was not a hierarchical model, should we allow users to assign a VLAN belongs to
-        # the parent Locations or the child locations of `device.location`?
+        location = self.parent.location if self.parent is not None else None
+        if location:
+            location_ids = location.ancestors(include_self=True).values_list("id", flat=True)
+        else:
+            location_ids = []
         if (
             self.untagged_vlan
             and self.untagged_vlan.locations.exists()
             and self.parent
-            and not self.untagged_vlan.locations.filter(id=self.parent.location_id).exists()
+            and not self.untagged_vlan.locations.filter(pk__in=location_ids).exists()
         ):
             raise ValidationError(
                 {
                     "untagged_vlan": (
                         f"The untagged VLAN ({self.untagged_vlan}) must have a common location as the interface's parent "
-                        f"device, or it must be global."
+                        f"device, or is in one of the parents of the interface's parent device's location, or it must be global."
                     )
                 }
             )

nautobot/dcim/tests/test_api.py

@@ -2198,6 +2198,34 @@ class InterfaceTest(Mixins.ModularDeviceComponentMixin, Mixins.BasePortTestMixin
             self.client.post(url, self.untagged_vlan_data, format="json", **self.header), status.HTTP_201_CREATED
         )
 
+    def test_tagged_vlan_must_be_in_the_location_or_parent_locations_of_the_parent_device(self):
+        self.add_permissions("dcim.add_interface")
+
+        interface_status = Status.objects.get_for_model(Interface).first()
+        location = self.devices[0].location
+        location_ids = [ancestor.id for ancestor in location.ancestors()]
+        non_valid_locations = Location.objects.exclude(pk__in=location_ids)
+        faulty_vlan = self.vlans[0]
+        faulty_vlan.locations.set([non_valid_locations.first().pk])
+        faulty_vlan.validated_save()
+        faulty_data = {
+            "device": self.devices[0].pk,
+            "name": "Test Vlans Interface",
+            "type": "virtual",
+            "status": interface_status.pk,
+            "mode": InterfaceModeChoices.MODE_TAGGED,
+            "parent_interface": self.interfaces[1].pk,
+            "tagged_vlans": [faulty_vlan.pk, self.vlans[1].pk],
+            "untagged_vlan": self.vlans[2].pk,
+        }
+        response = self.client.post(self._get_list_url(), data=faulty_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn(
+            b"must have the same location as the interface's parent device, or is in one of the parents of the interface's parent device's location, or "
+            b"it must be global.",
+            response.content,
+        )
+
     def test_interface_belonging_to_common_device_or_vc_allowed(self):
         """Test parent, bridge, and LAG interfaces belonging to common device or VC is valid"""
         self.add_permissions("dcim.add_interface")

nautobot/dcim/tests/test_forms.py

@@ -341,9 +341,25 @@ class InterfaceTestCase(TestCase):
             "tagged_vlans": [cls.vlan.pk],
         }
 
+    def test_interface_form_clean_vlan_location_success(self):
+        """Assert that form validation succeeds when matching locations/parent locations are associated to tagged VLAN"""
+        location = self.device.location
+        location_ids = location.ancestors(include_self=True).values_list("id", flat=True)
+        self.vlan.locations.set([location.id])
+        self.data["tagged_vlans"] = [self.vlan]
+        form = InterfaceForm(data=self.data, instance=self.interface)
+        self.assertTrue(form.is_valid())
+        self.vlan.locations.set(location_ids[:2])
+        self.data["tagged_vlans"] = [self.vlan]
+        form = InterfaceForm(data=self.data, instance=self.interface)
+        self.assertTrue(form.is_valid())
+
     def test_interface_form_clean_vlan_location_fail(self):
         """Assert that form validation fails when no matching locations are associated to tagged VLAN"""
-        self.vlan.locations.set(list(Location.objects.exclude(pk=self.device.location.pk))[:2])
+        location = self.device.location
+        location_ids = location.ancestors(include_self=True).values_list("id", flat=True)
+        self.vlan.locations.set(list(Location.objects.exclude(pk__in=location_ids))[:2])
+        self.data["tagged_vlans"] = [self.vlan]
         form = InterfaceForm(data=self.data, instance=self.interface)
         self.assertFalse(form.is_valid())
 

nautobot/dcim/tests/test_models.py

@@ -2376,19 +2376,57 @@ class InterfaceTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
         )
 
     def test_error_raised_when_adding_tagged_vlan_with_different_location_from_interface_parent_location(self):
+        intf_status = Status.objects.get_for_model(Interface).first()
+        intf_role = Role.objects.get_for_model(Interface).first()
+        location_type = LocationType.objects.get(name="Campus")
+        child_location = Location.objects.filter(parent__isnull=False, location_type=location_type).first()
+        self.device.location = child_location
+        self.device.validated_save()
+        # Same location as the device
+        interface = Interface.objects.create(
+            name="Test Interface 2",
+            mode=InterfaceModeChoices.MODE_TAGGED,
+            device=self.device,
+            status=intf_status,
+            role=intf_role,
+        )
+        self.other_location_vlan.locations.set([self.device.location.pk])
+        interface.tagged_vlans.set([self.other_location_vlan.pk])
+
+        # One of the parent locations of the device's location
+        interface = Interface.objects.create(
+            name="Test Interface 3",
+            mode=InterfaceModeChoices.MODE_TAGGED,
+            device=self.device,
+            status=intf_status,
+            role=intf_role,
+        )
+        self.other_location_vlan.locations.set([self.device.location.ancestors().first().pk])
+        interface.tagged_vlans.set([self.other_location_vlan.pk])
+
         with self.assertRaises(ValidationError) as err:
             interface = Interface.objects.create(
-                name="Test Interface",
+                name="Test Interface 1",
                 mode=InterfaceModeChoices.MODE_TAGGED,
                 device=self.device,
-                status=Status.objects.get_for_model(Interface).first(),
-                role=Role.objects.get_for_model(Interface).first(),
+                status=intf_status,
+                role=intf_role,
+            )
+            location_3 = Location.objects.create(
+                name="Invalid VLAN Location",
+                location_type=LocationType.objects.get(name="Campus"),
+                status=Status.objects.get_for_model(Location).first(),
             )
+            # clear the valid locations
+            self.other_location_vlan.locations.set([])
+            # assign the invalid location
+            self.other_location_vlan.location = location_3
+            self.other_location_vlan.validated_save()
             interface.tagged_vlans.add(self.other_location_vlan)
         self.assertEqual(
             err.exception.message_dict["tagged_vlans"][0],
             f"Tagged VLAN with names {[self.other_location_vlan.name]} must all belong to the "
-            f"same location as the interface's parent device, or it must be global.",
+            f"same location as the interface's parent device, one of the parent locations of the interface's parent device's location, or it must be global.",
         )
 
     def test_add_ip_addresses(self):

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/dcim/utils.py

@@ -139,12 +139,14 @@ def validate_interface_tagged_vlans(instance, model, pk_set):
         )
 
     # Filter the model objects based on the primary keys passed in kwargs and exclude the ones that have
-    # a location that is not the parent's location or None
-    # TODO: after Location model replaced Site, which was not a hierarchical model, should we allow users to add a VLAN
-    # belongs to the parent Location or the child location of the parent device to the `tagged_vlan` field of the interface?
-    device_location = getattr(instance.parent, "location", None)
+    # a location that is not the parent's location, or parent's location's ancestors, or None
+    location = getattr(instance.parent, "location", None)
+    if location:
+        location_ids = location.ancestors(include_self=True).values_list("id", flat=True)
+    else:
+        location_ids = []
     tagged_vlans = (
-        model.objects.filter(pk__in=pk_set).exclude(locations__isnull=True).exclude(locations__in=[device_location])
+        model.objects.filter(pk__in=pk_set).exclude(locations__isnull=True).exclude(locations__in=location_ids)
     )
 
     if tagged_vlans.count():
@@ -152,7 +154,8 @@ def validate_interface_tagged_vlans(instance, model, pk_set):
             {
                 "tagged_vlans": (
                     f"Tagged VLAN with names {list(tagged_vlans.values_list('name', flat=True))} must all belong to the "
-                    f"same location as the interface's parent device, or it must be global."
+                    "same location as the interface's parent device, "
+                    "one of the parent locations of the interface's parent device's location, or it must be global."
                 )
             }
         )

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/plugins/views.py

@@ -30,6 +30,21 @@ class InstalledAppsView(GenericView):
         data = []
         for app in apps.get_app_configs():
             if app.name in settings.PLUGINS:
+                try:
+                    reverse(app.home_view_name)
+                    home_url = app.home_view_name
+                except NoReverseMatch:
+                    home_url = None
+                try:
+                    reverse(app.config_view_name)
+                    config_url = app.config_view_name
+                except NoReverseMatch:
+                    config_url = None
+                try:
+                    reverse(app.docs_view_name)
+                    docs_url = app.docs_view_name
+                except NoReverseMatch:
+                    docs_url = None
                 data.append(
                     {
                         "name": app.verbose_name,
@@ -40,9 +55,9 @@ class InstalledAppsView(GenericView):
                         "description": app.description,
                         "version": app.version,
                         "actions": {
-                            "home": app.home_view_name,
-                            "configure": app.config_view_name,
-                            "docs": app.docs_view_name,
+                            "home": home_url,
+                            "configure": config_url,
+                            "docs": docs_url,
                         },
                     }
                 )

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)