nautobot 2.0.0a3__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

nautobot/extras/tests/test_api.py

@@ -1,5 +1,6 @@
 from datetime import datetime, timedelta
 import uuid
+import tempfile
 from unittest import mock, skip
 
 from django.conf import settings
@@ -25,10 +26,8 @@ from nautobot.dcim.models import (
     Rack,
     RackGroup,
 )
-
-# from nautobot.dcim.tests import test_views
-from nautobot.extras.api.nested_serializers import NestedJobResultSerializer
-from nautobot.extras.api.serializers import ConfigContextSerializer
+from nautobot.dcim.tests import test_views
+from nautobot.extras.api.serializers import ConfigContextSerializer, JobResultSerializer
 from nautobot.extras.choices import (
     DynamicGroupOperatorChoices,
     JobExecutionType,
@@ -67,11 +66,11 @@ from nautobot.extras.models import (
 )
 from nautobot.extras.models.jobs import JobHook, JobButton
 
-# from nautobot.extras.tests.test_relationships import RequiredRelationshipTestMixin
+from nautobot.extras.tests.test_relationships import RequiredRelationshipTestMixin
 from nautobot.extras.utils import TaggableClassesQuery
 
-# from nautobot.ipam.factory import VLANFactory
-from nautobot.ipam.models import VLANGroup  # , VLAN
+from nautobot.ipam.factory import VLANFactory
+from nautobot.ipam.models import VLANGroup, VLAN
 from nautobot.users.models import ObjectPermission
 
 
@@ -91,35 +90,24 @@ class AppTest(APITestCase):
 #
 
 
-@skip(reason="Content Types are BROKEN")
 class ComputedFieldTest(APIViewTestCases.APIViewTestCase):
     model = ComputedField
-    brief_fields = [
-        "content_type",
-        "display",
-        "id",
-        "label",
-        "url",
-    ]
     choices_fields = ["content_type"]
     create_data = [
         {
             "content_type": "dcim.location",
-            "slug": "cf4",
             "label": "Computed Field 4",
             "template": "{{ obj.name }}",
             "fallback_value": "error",
         },
         {
             "content_type": "dcim.location",
-            "slug": "cf5",
             "label": "Computed Field 5",
             "template": "{{ obj.name }}",
             "fallback_value": "error",
         },
         {
             "content_type": "dcim.location",
-            "slug": "cf6",
             "label": "Computed Field 6",
             "template": "{{ obj.name }}",
         },
@@ -132,7 +120,7 @@ class ComputedFieldTest(APIViewTestCases.APIViewTestCase):
     ]
     update_data = {
         "content_type": "dcim.location",
-        "slug": "cf1",
+        "key": "cf1",
         "label": "My Computed Field",
     }
     bulk_update_data = {
@@ -146,21 +134,21 @@ class ComputedFieldTest(APIViewTestCases.APIViewTestCase):
         location_ct = ContentType.objects.get_for_model(Location)
 
         ComputedField.objects.create(
-            slug="cf1",
+            key="cf1",
             label="Computed Field One",
             template="{{ obj.name }}",
             fallback_value="error",
             content_type=location_ct,
         )
         ComputedField.objects.create(
-            slug="cf2",
+            key="cf2",
             label="Computed Field Two",
             template="{{ obj.name }}",
             fallback_value="error",
             content_type=location_ct,
         )
         ComputedField.objects.create(
-            slug="cf3",
+            key="cf3",
             label="Computed Field Three",
             template="{{ obj.name }}",
             fallback_value="error",
@@ -186,7 +174,6 @@ class ComputedFieldTest(APIViewTestCases.APIViewTestCase):
 
 class ConfigContextTest(APIViewTestCases.APIViewTestCase):
     model = ConfigContext
-    brief_fields = ["display", "id", "name", "url"]
     create_data = [
         {
             "name": "Config Context 4",
@@ -219,8 +206,11 @@ class ConfigContextTest(APIViewTestCases.APIViewTestCase):
         manufacturer = Manufacturer.objects.first()
         devicetype = DeviceType.objects.create(manufacturer=manufacturer, model="Device Type 1", slug="device-type-1")
         devicerole = Role.objects.get_for_model(Device).first()
+        devicestatus = Status.objects.get_for_model(Device).first()
         location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
-        device = Device.objects.create(name="Device 1", device_type=devicetype, role=devicerole, location=location)
+        device = Device.objects.create(
+            name="Device 1", device_type=devicetype, role=devicerole, status=devicestatus, location=location
+        )
 
         # Test default config contexts (created at test setup)
         rendered_context = device.get_config_context()
@@ -231,7 +221,7 @@ class ConfigContextTest(APIViewTestCases.APIViewTestCase):
         # Test API response as well
         self.add_permissions("dcim.view_device")
         device_url = reverse("dcim-api:device-detail", kwargs={"pk": device.pk})
-        response = self.client.get(device_url, **self.header)
+        response = self.client.get(device_url + "?include=config_context", **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertIn("config_context", response.data)
         self.assertEqual(response.data["config_context"], {"foo": 123, "bar": 456, "baz": 789}, response.data)
@@ -242,7 +232,7 @@ class ConfigContextTest(APIViewTestCases.APIViewTestCase):
         configcontext4.locations.add(location)
         rendered_context = device.get_config_context()
         self.assertEqual(rendered_context["location_data"], "ABC")
-        response = self.client.get(device_url, **self.header)
+        response = self.client.get(device_url + "?include=config_context", **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertIn("config_context", response.data)
         self.assertEqual(response.data["config_context"]["location_data"], "ABC", response.data["config_context"])
@@ -253,7 +243,7 @@ class ConfigContextTest(APIViewTestCases.APIViewTestCase):
         configcontext5.locations.add(location)
         rendered_context = device.get_config_context()
         self.assertEqual(rendered_context["foo"], 999)
-        response = self.client.get(device_url, **self.header)
+        response = self.client.get(device_url + "?include=config_context", **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertIn("config_context", response.data)
         self.assertEqual(response.data["config_context"]["foo"], 999, response.data["config_context"])
@@ -265,7 +255,7 @@ class ConfigContextTest(APIViewTestCases.APIViewTestCase):
         configcontext6.locations.add(location2)
         rendered_context = device.get_config_context()
         self.assertEqual(rendered_context["bar"], 456)
-        response = self.client.get(device_url, **self.header)
+        response = self.client.get(device_url + "?include=config_context", **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertIn("config_context", response.data)
         self.assertEqual(response.data["config_context"]["bar"], 456, response.data["config_context"])
@@ -289,7 +279,7 @@ class ConfigContextTest(APIViewTestCases.APIViewTestCase):
         }
         response = self.client.post(self._get_list_url(), data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_201_CREATED)
-        self.assertEqual(response.data["config_context_schema"]["id"], str(schema.pk))
+        self.assertEqual(response.data["config_context_schema"], self.absolute_api_url(schema))
 
     def test_schema_validation_fails(self):
         """
@@ -326,7 +316,6 @@ class ConfigContextTest(APIViewTestCases.APIViewTestCase):
 
 class ConfigContextSchemaTest(APIViewTestCases.APIViewTestCase):
     model = ConfigContextSchema
-    brief_fields = ["display", "id", "name", "slug", "url"]
     create_data = [
         {
             "name": "Schema 4",
@@ -389,31 +378,33 @@ class ContentTypeTest(APITestCase):
 
 
 class CreatedUpdatedFilterTest(APITestCase):
-    def setUp(self):
-        super().setUp()
-
-        self.location1 = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
-        self.rackgroup1 = RackGroup.objects.create(
-            location=self.location1, name="Test Rack Group 1", slug="test-rack-group-1"
-        )
-        self.rackrole1 = Role.objects.get_for_model(Rack).first()
-        self.rack1 = Rack.objects.create(
-            location=self.location1,
-            rack_group=self.rackgroup1,
-            role=self.rackrole1,
+    @classmethod
+    def setUpTestData(cls):
+        cls.location1 = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
+        cls.rackgroup1 = RackGroup.objects.create(
+            location=cls.location1, name="Test Rack Group 1", slug="test-rack-group-1"
+        )
+        cls.rackrole1 = Role.objects.get_for_model(Rack).first()
+        cls.rackstatus1 = Status.objects.get_for_model(Rack).first()
+        cls.rack1 = Rack.objects.create(
+            location=cls.location1,
+            rack_group=cls.rackgroup1,
+            role=cls.rackrole1,
+            status=cls.rackstatus1,
             name="Test Rack 1",
             u_height=42,
         )
-        self.rack2 = Rack.objects.create(
-            location=self.location1,
-            rack_group=self.rackgroup1,
-            role=self.rackrole1,
+        cls.rack2 = Rack.objects.create(
+            location=cls.location1,
+            rack_group=cls.rackgroup1,
+            role=cls.rackrole1,
+            status=cls.rackstatus1,
             name="Test Rack 2",
             u_height=42,
         )
 
         # change the created and last_updated of one
-        Rack.objects.filter(pk=self.rack2.pk).update(
+        Rack.objects.filter(pk=cls.rack2.pk).update(
             created=make_aware(datetime(2001, 2, 3, 0, 1, 2, 3)),
             last_updated=make_aware(datetime(2001, 2, 3, 1, 2, 3, 4)),
         )
@@ -483,12 +474,10 @@ class CreatedUpdatedFilterTest(APITestCase):
         self.assertEqual(response.data["results"][0]["id"], str(self.rack2.pk))
 
 
-@skip(reason="Content Types are BROKEN")
 class CustomFieldTest(APIViewTestCases.APIViewTestCase):
     """Tests for the CustomField REST API."""
 
     model = CustomField
-    brief_fields = ["display", "id", "key", "url"]
     create_data = [
         {
             "content_types": ["dcim.location"],
@@ -561,7 +550,6 @@ class CustomFieldTest(APIViewTestCases.APIViewTestCase):
 
 class CustomLinkTest(APIViewTestCases.APIViewTestCase):
     model = CustomLink
-    brief_fields = ["content_type", "display", "id", "name", "url"]
     create_data = [
         {
             "content_type": "dcim.location",
@@ -627,10 +615,17 @@ class DynamicGroupTestMixin:
     def setUpTestData(cls):
         # Create the objects required for devices.
         location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
         locations = (
-            Location.objects.create(name="Location 1", slug="location-1", location_type=location_type),
-            Location.objects.create(name="Location 2", slug="location-2", location_type=location_type),
-            Location.objects.create(name="Location 3", slug="location-3", location_type=location_type),
+            Location.objects.create(
+                name="Location 1", slug="location-1", location_type=location_type, status=location_status
+            ),
+            Location.objects.create(
+                name="Location 2", slug="location-2", location_type=location_type, status=location_status
+            ),
+            Location.objects.create(
+                name="Location 3", slug="location-3", location_type=location_type, status=location_status
+            ),
         )
 
         manufacturer = Manufacturer.objects.first()
@@ -686,7 +681,6 @@ class DynamicGroupTestMixin:
 
 class DynamicGroupTest(DynamicGroupTestMixin, APIViewTestCases.APIViewTestCase):
     model = DynamicGroup
-    brief_fields = ["content_type", "display", "id", "name", "url"]
     choices_fields = ["content_type"]
     create_data = [
         {
@@ -719,7 +713,6 @@ class DynamicGroupTest(DynamicGroupTestMixin, APIViewTestCases.APIViewTestCase):
 
 class DynamicGroupMembershipTest(DynamicGroupTestMixin, APIViewTestCases.APIViewTestCase):
     model = DynamicGroupMembership
-    brief_fields = ["display", "group", "id", "operator", "parent_group", "url", "weight"]
     choices_fields = ["operator"]
 
     @classmethod
@@ -778,10 +771,18 @@ class DynamicGroupMembershipTest(DynamicGroupTestMixin, APIViewTestCases.APIView
             },
         ]
 
+    # TODO: Either improve test base or or write a more specific test for this model.
+    @skip("DynamicGroupMembership has a `name` property but it's the Group name and not exposed on the API")
+    def test_list_objects_ascending_ordered(self):
+        pass
+
+    @skip("DynamicGroupMembership has a `name` property but it's the Group name and not exposed on the API")
+    def test_list_objects_descending_ordered(self):
+        pass
+
 
 class ExportTemplateTest(APIViewTestCases.APIViewTestCase):
     model = ExportTemplate
-    brief_fields = ["display", "id", "name", "url"]
     create_data = [
         {
             "content_type": "dcim.device",
@@ -827,12 +828,12 @@ class ExportTemplateTest(APIViewTestCases.APIViewTestCase):
 
 class GitRepositoryTest(APIViewTestCases.APIViewTestCase):
     model = GitRepository
-    brief_fields = ["display", "id", "name", "url"]
     bulk_update_data = {
         "branch": "develop",
     }
     choices_fields = ["provided_contents"]
     slug_source = "name"
+    slugify_function = staticmethod(slugify_dashes_to_underscores)
 
     @classmethod
     def setUpTestData(cls):
@@ -844,37 +845,38 @@ class GitRepositoryTest(APIViewTestCases.APIViewTestCase):
         cls.repos = (
             GitRepository(
                 name="Repo 1",
-                slug="repo-1",
+                slug="repo_1",
                 remote_url="https://example.com/repo1.git",
                 secrets_group=secrets_groups[0],
             ),
             GitRepository(
                 name="Repo 2",
-                slug="repo-2",
+                slug="repo_2",
                 remote_url="https://example.com/repo2.git",
                 secrets_group=secrets_groups[0],
             ),
-            GitRepository(name="Repo 3", slug="repo-3", remote_url="https://example.com/repo3.git"),
+            GitRepository(name="Repo 3", slug="repo_3", remote_url="https://example.com/repo3.git"),
         )
         for repo in cls.repos:
-            repo.save(trigger_resync=False)
+            repo.save()
 
         cls.create_data = [
             {
                 "name": "New Git Repository 1",
-                "slug": "new-git-repository-1",
+                "slug": "new_git_repository_1",
                 "remote_url": "https://example.com/newrepo1.git",
                 "secrets_group": secrets_groups[1].pk,
+                "provided_contents": ["extras.configcontext", "extras.exporttemplate"],
             },
             {
                 "name": "New Git Repository 2",
-                "slug": "new-git-repository-2",
+                "slug": "new_git_repository_2",
                 "remote_url": "https://example.com/newrepo2.git",
                 "secrets_group": secrets_groups[1].pk,
             },
             {
                 "name": "New Git Repository 3",
-                "slug": "new-git-repository-3",
+                "slug": "new_git_repository_3",
                 "remote_url": "https://example.com/newrepo3.git",
                 "secrets_group": secrets_groups[1].pk,
             },
@@ -885,6 +887,13 @@ class GitRepositoryTest(APIViewTestCases.APIViewTestCase):
             },
         ]
 
+        # slug is enforced non-editable in clean because we want it to be providable by the user on creation
+        # but not modified afterward
+        cls.update_data = {
+            "name": "A Different Repo Name",
+            "remote_url": "https://example.com/fake.git",
+        }
+
     @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
     @mock.patch("nautobot.extras.api.views.get_worker_count")
     def test_run_git_sync_no_celery_worker(self, mock_get_worker_count):
@@ -920,10 +929,9 @@ class GitRepositoryTest(APIViewTestCases.APIViewTestCase):
         self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
-    @mock.patch("nautobot.extras.api.views.get_worker_count")
-    def test_run_git_sync_with_permissions(self, mock_get_worker_count):
+    @mock.patch("nautobot.extras.api.views.get_worker_count", return_value=1)
+    def test_run_git_sync_with_permissions(self, _):
         """Git sync request can be submitted successfully."""
-        mock_get_worker_count.return_value = 1
         self.add_permissions("extras.add_gitrepository")
         self.add_permissions("extras.change_gitrepository")
         url = reverse("extras-api:gitrepository-sync", kwargs={"pk": self.repos[0].id})
@@ -937,7 +945,7 @@ class GitRepositoryTest(APIViewTestCases.APIViewTestCase):
         url = self._get_list_url()
         data = {
             "name": "plugin_test",
-            "slug": "plugin-test",
+            "slug": "plugin_test",
             "remote_url": "https://localhost/plugin-test",
             "provided_contents": ["example_plugin.textfile"],
         }
@@ -948,8 +956,6 @@ class GitRepositoryTest(APIViewTestCases.APIViewTestCase):
 
 class GraphQLQueryTest(APIViewTestCases.APIViewTestCase):
     model = GraphQLQuery
-    brief_fields = ["display", "id", "name", "url"]
-
     create_data = [
         {
             "name": "graphql-query-4",
@@ -1097,7 +1103,6 @@ class ImageAttachmentTest(
     APIViewTestCases.DeleteObjectViewTestCase,
 ):
     model = ImageAttachment
-    brief_fields = ["display", "id", "image", "name", "url"]
     choices_fields = ["content_type"]
 
     @classmethod
@@ -1131,6 +1136,15 @@ class ImageAttachmentTest(
             image_width=100,
         )
 
+    # TODO: Unskip after resolving #2908, #2909
+    @skip("DRF's built-in OrderingFilter triggering natural key attribute error in our base")
+    def test_list_objects_ascending_ordered(self):
+        pass
+
+    @skip("DRF's built-in OrderingFilter triggering natural key attribute error in our base")
+    def test_list_objects_descending_ordered(self):
+        pass
+
 
 class JobTest(
     # note no CreateObjectViewTestCase - we do not support user creation of Job records
@@ -1142,7 +1156,6 @@ class JobTest(
     """Test cases for the Jobs REST API."""
 
     model = Job
-    brief_fields = ["display", "grouping", "id", "job_class_name", "module_name", "name", "slug", "source", "url"]
     choices_fields = None
     update_data = {
         # source, module_name, job_class_name, installed are NOT editable
@@ -1150,18 +1163,15 @@ class JobTest(
         "grouping": "Overridden grouping",
         "name_override": True,
         "name": "Overridden name",
-        "slug": "overridden-slug",
         "description_override": True,
         "description": "This is an overridden description.",
         "enabled": True,
         "approval_required_override": True,
         "approval_required": True,
-        "commit_default_override": True,
-        "commit_default": False,
+        "dryrun_default_override": True,
+        "dryrun_default": True,
         "hidden_override": True,
         "hidden": True,
-        "read_only_override": True,
-        "read_only": True,
         "soft_time_limit_override": True,
         "soft_time_limit": 350.1,
         "time_limit_override": True,
@@ -1181,14 +1191,16 @@ class JobTest(
 
     def setUp(self):
         super().setUp()
-        self.default_job_name = "local/api_test_job/APITestJob"
+        self.default_job_name = "api_test_job.APITestJob"
+        self.job_class = get_job(self.default_job_name)
+        self.assertIsNotNone(self.job_class)
         self.job_model = Job.objects.get_for_class_path(self.default_job_name)
         self.job_model.enabled = True
         self.job_model.validated_save()
 
     run_success_response_status = status.HTTP_201_CREATED
 
-    def get_run_url(self, class_path="local/api_test_job/APITestJob"):
+    def get_run_url(self, class_path="api_test_job.APITestJob"):
         job_model = Job.objects.get_for_class_path(class_path)
         return reverse("extras-api:job-run", kwargs={"pk": job_model.pk})
 
@@ -1208,7 +1220,7 @@ class JobTest(
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_update_job_with_sensitive_variables_set_approval_required_to_true(self):
-        job_model = Job.objects.get_for_class_path("local/api_test_job/APITestJob")
+        job_model = Job.objects.get_for_class_path("api_test_job.APITestJob")
         job_model.has_sensitive_variables = True
         job_model.has_sensitive_variables_override = True
         job_model.validated_save()
@@ -1230,7 +1242,7 @@ class JobTest(
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_update_approval_required_job_set_has_sensitive_variables_to_true(self):
-        job_model = Job.objects.get_for_class_path("local/api_test_job/APITestJob")
+        job_model = Job.objects.get_for_class_path("api_test_job.APITestJob")
         job_model.approval_required = True
         job_model.approval_required_override = True
         job_model.validated_save()
@@ -1275,7 +1287,7 @@ class JobTest(
         mock_get_worker_count.return_value = 1
         obj_perm = ObjectPermission(
             name="Test permission",
-            constraints={"module_name__in": ["test_pass", "test_fail"]},
+            constraints={"module_name__in": ["pass", "fail"]},
             actions=["run"],
         )
         obj_perm.save()
@@ -1289,10 +1301,10 @@ class JobTest(
         self.assertHttpStatus(response, status.HTTP_404_NOT_FOUND)
 
         # Try post to permitted job
-        job_model = Job.objects.get_for_class_path("local/test_pass/TestPass")
+        job_model = Job.objects.get_for_class_path("pass.TestPass")
         job_model.enabled = True
         job_model.validated_save()
-        url = self.get_run_url("local/test_pass/TestPass")
+        url = self.get_run_url("pass.TestPass")
         response = self.client.post(url, **self.header)
         self.assertHttpStatus(response, self.run_success_response_status)
 
@@ -1320,7 +1332,6 @@ class JobTest(
         self.add_permissions("extras.run_job")
 
         job_model = Job(
-            source="local",
             module_name="uninstalled_module",
             job_class_name="NoSuchJob",
             grouping="Uninstalled Module",
@@ -1330,7 +1341,7 @@ class JobTest(
         )
         job_model.validated_save()
 
-        url = self.get_run_url("local/uninstalled_module/NoSuchJob")
+        url = self.get_run_url("uninstalled_module.NoSuchJob")
         with disable_warnings("django.request"):
             response = self.client.post(url, {}, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_405_METHOD_NOT_ALLOWED)
@@ -1351,7 +1362,6 @@ class JobTest(
 
         data = {
             "data": job_data,
-            "commit": True,
         }
 
         url = self.get_run_url()
@@ -1377,7 +1387,6 @@ class JobTest(
 
         data = {
             "data": job_data,
-            "commit": True,
             "schedule": {
                 "name": "test",
                 "interval": "future",
@@ -1390,17 +1399,19 @@ class JobTest(
         self.assertHttpStatus(response, self.run_success_response_status)
 
         schedule = ScheduledJob.objects.last()
-        self.assertEqual(schedule.kwargs["data"]["var4"], str(device_role.pk))
+        self.assertEqual(schedule.kwargs["var4"], str(device_role.pk))
 
         self.assertIn("scheduled_job", response.data)
         self.assertIn("job_result", response.data)
         self.assertEqual(response.data["scheduled_job"]["id"], str(schedule.pk))
+        self.assertEqual(response.data["scheduled_job"]["url"], self.absolute_api_url(schedule))
+        self.assertEqual(response.data["scheduled_job"]["name"], schedule.name)
+        # Python < 3.11 doesn't understand the datetime string "2023-04-27T18:33:16.017865Z",
+        # but it *does* understand the string "2023-04-27T18:33:17.330836+00:00"
         self.assertEqual(
-            response.data["scheduled_job"]["url"],
-            "http://nautobot.example.com" + reverse("extras-api:scheduledjob-detail", kwargs={"pk": schedule.pk}),
+            datetime.fromisoformat(response.data["scheduled_job"]["start_time"].replace("Z", "+00:00")),
+            schedule.start_time,
         )
-        self.assertEqual(response.data["scheduled_job"]["name"], schedule.name)
-        self.assertEqual(response.data["scheduled_job"]["start_time"], schedule.start_time)
         self.assertEqual(response.data["scheduled_job"]["interval"], schedule.interval)
         self.assertIsNone(response.data["job_result"])
 
@@ -1429,7 +1440,6 @@ class JobTest(
 
         data = {
             "data": job_data,
-            "commit": True,
             # schedule is omitted
         }
 
@@ -1445,13 +1455,15 @@ class JobTest(
         self.assertIsNotNone(schedule)
         self.assertEqual(schedule.interval, JobExecutionType.TYPE_IMMEDIATELY)
         self.assertEqual(schedule.approval_required, self.job_model.approval_required)
-        self.assertEqual(schedule.kwargs["data"]["var4"], str(device_role.pk))
+        self.assertEqual(schedule.kwargs["var4"], str(device_role.pk))
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     @mock.patch("nautobot.extras.api.views.get_worker_count")
-    def test_run_job_object_var_lookup(self, mock_get_worker_count):
+    @mock.patch("nautobot.extras.models.jobs.JobResult.enqueue_job")
+    def test_run_job_object_var_lookup(self, mock_enqueue_job, mock_get_worker_count):
         """Job run requests can reference objects by their attributes."""
         mock_get_worker_count.return_value = 1
+        mock_enqueue_job.return_value = None
         self.add_permissions("extras.run_job")
         device_role = Role.objects.get_for_model(Device).first()
         job_data = {
@@ -1463,7 +1475,7 @@ class JobTest(
 
         # This handles things like ObjectVar fields looked up by non-UUID
         # Jobs are executed with deserialized data
-        deserialized_data = get_job(self.default_job_name).deserialize_data(job_data)
+        deserialized_data = self.job_class.deserialize_data(job_data)
 
         self.assertEqual(
             deserialized_data,
@@ -1474,24 +1486,39 @@ class JobTest(
         response = self.client.post(url, {"data": job_data}, format="json", **self.header)
         self.assertHttpStatus(response, self.run_success_response_status)
 
-        job_result = JobResult.objects.get(name=self.default_job_name)
-        self.assertIn("data", job_result.task_kwargs)
+        # Ensure the enqueue_job args deserialize to the same as originally inputted
+        expected_enqueue_job_args = (self.job_model, self.user)
+        expected_enqueue_job_kwargs = {
+            "task_queue": settings.CELERY_TASK_DEFAULT_QUEUE,
+            **self.job_class.serialize_data(deserialized_data),
+        }
+        mock_enqueue_job.assert_called_with(*expected_enqueue_job_args, **expected_enqueue_job_kwargs)
 
-        # Ensure the stored task_kwargs deserialize to the same as originally inputted
-        self.assertEqual(
-            get_job("local/api_test_job/APITestJob").deserialize_data(job_result.task_kwargs["data"]), deserialized_data
-        )
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    @mock.patch("nautobot.extras.api.views.get_worker_count")
+    def test_run_job_response_job_result(self, mock_get_worker_count):
+        """Test job run response contains nested job result."""
+        mock_get_worker_count.return_value = 1
+        self.add_permissions("extras.run_job")
+        device_role = Role.objects.get_for_model(Device).first()
+        job_data = {
+            "var1": "FooBar",
+            "var2": 123,
+            "var3": False,
+            "var4": {"name": device_role.name},
+        }
+
+        url = self.get_run_url()
+        response = self.client.post(url, {"data": job_data}, format="json", **self.header)
+        self.assertHttpStatus(response, self.run_success_response_status)
+
+        job_result = JobResult.objects.get(name=self.job_model.name)
 
         self.assertIn("scheduled_job", response.data)
         self.assertIn("job_result", response.data)
         self.assertIsNone(response.data["scheduled_job"])
-        # The urls in a NestedJobResultSerializer depends on the request context, which we don't have
         data_job_result = response.data["job_result"]
-        del data_job_result["url"]
-        del data_job_result["user"]["url"]
-        expected_data_job_result = NestedJobResultSerializer(job_result, context={"request": None}).data
-        del expected_data_job_result["url"]
-        del expected_data_job_result["user"]["url"]
+        expected_data_job_result = JobResultSerializer(job_result, context={"request": response.wsgi_request}).data
         self.assertEqual(data_job_result, expected_data_job_result)
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
@@ -1501,7 +1528,7 @@ class JobTest(
 
         test_file = SimpleUploadedFile(name="test_file.txt", content=b"I am content.\n")
 
-        job_model = Job.objects.get_for_class_path("local/test_field_order/TestFieldOrder")
+        job_model = Job.objects.get_for_class_path("field_order.TestFieldOrder")
         job_model.enabled = True
         job_model.validated_save()
 
@@ -1512,10 +1539,9 @@ class JobTest(
             "var2": "Ground control to Major Tom",
             "var23": "Commencing countdown, engines on",
             "var1": test_file,
-            "_commit": True,
         }
 
-        url = self.get_run_url(class_path="local/test_field_order/TestFieldOrder")
+        url = self.get_run_url(class_path="field_order.TestFieldOrder")
         response = self.client.post(url, data=job_data, **self.header)
         self.assertHttpStatus(response, self.run_success_response_status)
 
@@ -1526,7 +1552,7 @@ class JobTest(
 
         test_file = SimpleUploadedFile(name="test_file.txt", content=b"I am content.\n")
 
-        job_model = Job.objects.get_for_class_path("local/test_field_order/TestFieldOrder")
+        job_model = Job.objects.get_for_class_path("field_order.TestFieldOrder")
         job_model.enabled = True
         job_model.validated_save()
 
@@ -1539,7 +1565,7 @@ class JobTest(
             "var1": test_file,
         }
 
-        url = self.get_run_url(class_path="local/test_field_order/TestFieldOrder")
+        url = self.get_run_url(class_path="field_order.TestFieldOrder")
         response = self.client.post(url, data=job_data, **self.header)
         self.assertHttpStatus(response, self.run_success_response_status)
 
@@ -1550,7 +1576,7 @@ class JobTest(
 
         test_file = SimpleUploadedFile(name="test_file.txt", content=b"I am content.\n")
 
-        job_model = Job.objects.get_for_class_path("local/test_field_order/TestFieldOrder")
+        job_model = Job.objects.get_for_class_path("field_order.TestFieldOrder")
         job_model.enabled = True
         job_model.validated_save()
 
@@ -1561,13 +1587,12 @@ class JobTest(
             "var2": "Ground control to Major Tom",
             "var23": "Commencing countdown, engines on",
             "var1": test_file,
-            "_commit": True,
             "_schedule_start_time": str(datetime.now() + timedelta(minutes=1)),
             "_schedule_interval": "future",
             "_schedule_name": "test",
         }
 
-        url = self.get_run_url(class_path="local/test_field_order/TestFieldOrder")
+        url = self.get_run_url(class_path="field_order.TestFieldOrder")
         response = self.client.post(url, data=job_data, **self.header)
         self.assertHttpStatus(response, self.run_success_response_status)
 
@@ -1580,7 +1605,6 @@ class JobTest(
         d = Role.objects.get_for_model(Device).first()
         data = {
             "data": {"var1": "x", "var2": 1, "var3": False, "var4": d.pk},
-            "commit": True,
             "schedule": {
                 "start_time": str(datetime.now() + timedelta(minutes=1)),
                 "interval": "future",
@@ -1593,17 +1617,17 @@ class JobTest(
         self.assertHttpStatus(response, self.run_success_response_status)
 
         schedule = ScheduledJob.objects.last()
-        self.assertEqual(schedule.kwargs["scheduled_job_pk"], str(schedule.pk))
-
         self.assertIn("scheduled_job", response.data)
         self.assertIn("job_result", response.data)
         self.assertEqual(response.data["scheduled_job"]["id"], str(schedule.pk))
+        self.assertEqual(response.data["scheduled_job"]["url"], self.absolute_api_url(schedule))
+        self.assertEqual(response.data["scheduled_job"]["name"], schedule.name)
+        # Python < 3.11 doesn't understand the datetime string "2023-04-27T18:33:16.017865Z",
+        # but it *does* understand the string "2023-04-27T18:33:17.330836+00:00"
         self.assertEqual(
-            response.data["scheduled_job"]["url"],
-            "http://nautobot.example.com" + reverse("extras-api:scheduledjob-detail", kwargs={"pk": schedule.pk}),
+            datetime.fromisoformat(response.data["scheduled_job"]["start_time"].replace("Z", "+00:00")),
+            schedule.start_time,
         )
-        self.assertEqual(response.data["scheduled_job"]["name"], schedule.name)
-        self.assertEqual(response.data["scheduled_job"]["start_time"], schedule.start_time)
         self.assertEqual(response.data["scheduled_job"]["interval"], schedule.interval)
         self.assertIsNone(response.data["job_result"])
 
@@ -1620,7 +1644,6 @@ class JobTest(
         url = reverse("extras-api:job-run", kwargs={"pk": job_model.pk})
         data = {
             "data": {},
-            "commit": True,
             "schedule": {
                 "start_time": str(datetime.now() + timedelta(minutes=1)),
                 "interval": "future",
@@ -1651,7 +1674,6 @@ class JobTest(
         url = reverse("extras-api:job-run", kwargs={"pk": job_model.pk})
         data = {
             "data": {},
-            "commit": True,
             "schedule": {
                 "interval": "immediately",
                 "name": "test",
@@ -1668,30 +1690,27 @@ class JobTest(
         )
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
-    @mock.patch("nautobot.extras.api.views.get_worker_count")
-    def test_run_a_job_with_sensitive_variables_immediately(self, mock_get_worker_count):
-        mock_get_worker_count.return_value = 1
+    @mock.patch("nautobot.extras.api.views.get_worker_count", return_value=1)
+    def test_run_a_job_with_sensitive_variables_immediately(self, _):
         self.add_permissions("extras.run_job")
         d = Role.objects.get_for_model(Device).first()
         data = {
             "data": {"var1": "x", "var2": 1, "var3": False, "var4": d.pk},
-            "commit": True,
             "schedule": {
                 "interval": "immediately",
                 "name": "test",
             },
         }
-        job = Job.objects.get_for_class_path(self.default_job_name)
-        job.has_sensitive_variables = True
-        job.has_sensitive_variables_override = True
-        job.validated_save()
+        self.job_model.has_sensitive_variables = True
+        self.job_model.has_sensitive_variables_override = True
+        self.job_model.validated_save()
 
         url = self.get_run_url()
         response = self.client.post(url, data, format="json", **self.header)
         self.assertHttpStatus(response, self.run_success_response_status)
 
-        job_result = JobResult.objects.get(name=self.default_job_name)
-        self.assertEqual(job_result.task_kwargs, None)
+        job_result = JobResult.objects.get(name=self.job_model.name)
+        self.assertEqual(job_result.task_kwargs, {})
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     @mock.patch("nautobot.extras.api.views.get_worker_count")
@@ -1701,7 +1720,6 @@ class JobTest(
         d = Role.objects.get_for_model(Device).first()
         data = {
             "data": {"var1": "x", "var2": 1, "var3": False, "var4": d.pk},
-            "commit": True,
             "schedule": {
                 "start_time": str(datetime.now() - timedelta(minutes=1)),
                 "interval": "future",
@@ -1721,7 +1739,6 @@ class JobTest(
         d = Role.objects.get_for_model(Device).first()
         data = {
             "data": {"var1": "x", "var2": 1, "var3": False, "var4": d.pk},
-            "commit": True,
             "schedule": {
                 "start_time": str(datetime.now() + timedelta(minutes=1)),
                 "interval": "hourly",
@@ -1738,12 +1755,14 @@ class JobTest(
         self.assertIn("scheduled_job", response.data)
         self.assertIn("job_result", response.data)
         self.assertEqual(response.data["scheduled_job"]["id"], str(schedule.pk))
+        self.assertEqual(response.data["scheduled_job"]["url"], self.absolute_api_url(schedule))
+        self.assertEqual(response.data["scheduled_job"]["name"], schedule.name)
+        # Python < 3.11 doesn't understand the datetime string "2023-04-27T18:33:16.017865Z",
+        # but it *does* understand the string "2023-04-27T18:33:17.330836+00:00"
         self.assertEqual(
-            response.data["scheduled_job"]["url"],
-            "http://nautobot.example.com" + reverse("extras-api:scheduledjob-detail", kwargs={"pk": schedule.pk}),
+            datetime.fromisoformat(response.data["scheduled_job"]["start_time"].replace("Z", "+00:00")),
+            schedule.start_time,
         )
-        self.assertEqual(response.data["scheduled_job"]["name"], schedule.name)
-        self.assertEqual(response.data["scheduled_job"]["start_time"], schedule.start_time)
         self.assertEqual(response.data["scheduled_job"]["interval"], schedule.interval)
         self.assertIsNone(response.data["job_result"])
 
@@ -1753,7 +1772,6 @@ class JobTest(
 
         data = {
             "data": "invalid",
-            "commit": True,
         }
 
         url = self.get_run_url()
@@ -1773,7 +1791,6 @@ class JobTest(
 
         data = {
             "data": job_data,
-            "commit": True,
         }
 
         url = self.get_run_url()
@@ -1792,7 +1809,6 @@ class JobTest(
 
         data = {
             "data": job_data,
-            "commit": True,
         }
 
         url = self.get_run_url()
@@ -1808,7 +1824,6 @@ class JobTest(
         d = Role.objects.get_for_model(Device).first()
         data = {
             "data": {"var1": "x", "var2": 1, "var3": False, "var4": d.pk},
-            "commit": True,
             "task_queue": "invalid",
         }
 
@@ -1827,7 +1842,6 @@ class JobTest(
         d = Role.objects.get_for_model(Device).first()
         data = {
             "data": {"var1": "x", "var2": 1, "var3": False, "var4": d.pk},
-            "commit": True,
             "task_queue": settings.CELERY_TASK_DEFAULT_QUEUE,
         }
 
@@ -1840,21 +1854,28 @@ class JobTest(
     def test_run_job_with_default_queue_with_empty_job_model_task_queues(self, _):
         self.add_permissions("extras.run_job")
         data = {
-            "commit": True,
             "task_queue": settings.CELERY_TASK_DEFAULT_QUEUE,
         }
 
-        job_model = Job.objects.get_for_class_path("local/test_pass/TestPass")
+        job_model = Job.objects.get_for_class_path("pass.TestPass")
         job_model.enabled = True
         job_model.validated_save()
-        url = self.get_run_url("local/test_pass/TestPass")
+        url = self.get_run_url("pass.TestPass")
         response = self.client.post(url, data, format="json", **self.header)
         self.assertHttpStatus(response, self.run_success_response_status)
 
+    # TODO: Either improve test base or or write a more specific test for this model.
+    @skip("Job has a `name` property but grouping is also used to sort Jobs")
+    def test_list_objects_ascending_ordered(self):
+        pass
+
+    @skip("Job has a `name` property but grouping is also used to sort Jobs")
+    def test_list_objects_descending_ordered(self):
+        pass
+
 
 class JobHookTest(APIViewTestCases.APIViewTestCase):
     model = JobHook
-    brief_fields = ["display", "id", "name", "url"]
     choices_fields = []
     update_data = {
         "name": "Overridden name",
@@ -1961,7 +1982,6 @@ class JobHookTest(APIViewTestCases.APIViewTestCase):
 
 class JobButtonTest(APIViewTestCases.APIViewTestCase):
     model = JobButton
-    brief_fields = ["display", "id", "name", "url"]
     choices_fields = ["button_class"]
 
     @classmethod
@@ -2020,49 +2040,37 @@ class JobResultTest(
     APIViewTestCases.DeleteObjectViewTestCase,
 ):
     model = JobResult
-    brief_fields = ["date_created", "date_done", "display", "id", "name", "status", "url", "user"]
 
     @classmethod
     def setUpTestData(cls):
         jobs = Job.objects.all()[:2]
-        job_ct = ContentType.objects.get_for_model(Job)
-        git_ct = ContentType.objects.get_for_model(GitRepository)
 
         JobResult.objects.create(
             job_model=jobs[0],
             name=jobs[0].class_path,
-            obj_type=job_ct,
-            date_done=datetime.now(),
+            date_done=now(),
             user=None,
             status=JobResultStatusChoices.STATUS_SUCCESS,
-            data={"output": "\nRan for 3 seconds"},
-            task_kwargs=None,
+            task_kwargs={},
             scheduled_job=None,
-            task_id=uuid.uuid4(),
         )
         JobResult.objects.create(
             job_model=None,
-            name="Git Repository",
-            obj_type=git_ct,
-            date_done=datetime.now(),
+            name="deleted_module.deleted_job",
+            date_done=now(),
             user=None,
             status=JobResultStatusChoices.STATUS_SUCCESS,
-            data=None,
             task_kwargs={"repository_pk": uuid.uuid4()},
             scheduled_job=None,
-            task_id=uuid.uuid4(),
         )
         JobResult.objects.create(
             job_model=jobs[1],
             name=jobs[1].class_path,
-            obj_type=job_ct,
             date_done=None,
             user=None,
             status=JobResultStatusChoices.STATUS_PENDING,
-            data=None,
             task_kwargs={"data": {"device": uuid.uuid4(), "multichoices": ["red", "green"], "checkbox": False}},
             scheduled_job=None,
-            task_id=uuid.uuid4(),
         )
 
 
@@ -2071,27 +2079,11 @@ class JobLogEntryTest(
     APIViewTestCases.ListObjectsViewTestCase,
 ):
     model = JobLogEntry
-    brief_fields = [
-        "absolute_url",
-        "created",
-        "display",
-        "grouping",
-        "id",
-        "job_result",
-        "log_level",
-        "log_object",
-        "message",
-        "url",
-    ]
     choices_fields = []
 
     @classmethod
     def setUpTestData(cls):
-        cls.job_result = JobResult.objects.create(
-            name="test",
-            task_id=uuid.uuid4(),
-            obj_type=ContentType.objects.get_for_model(GitRepository),
-        )
+        cls.job_result = JobResult.objects.create(name="test")
 
         for log_level in ("debug", "info", "success", "warning"):
             JobLogEntry.objects.create(
@@ -2114,16 +2106,15 @@ class ScheduledJobTest(
     APIViewTestCases.ListObjectsViewTestCase,
 ):
     model = ScheduledJob
-    brief_fields = ["crontab", "display", "id", "interval", "name", "start_time", "url"]
     choices_fields = []
 
     @classmethod
     def setUpTestData(cls):
         user = User.objects.create(username="user1", is_active=True)
-        job_model = Job.objects.get_for_class_path("local/test_pass/TestPass")
+        job_model = Job.objects.get_for_class_path("pass.TestPass")
         ScheduledJob.objects.create(
             name="test1",
-            task="nautobot.extras.jobs.scheduled_job_handler",
+            task="pass.TestPass",
             job_class=job_model.class_path,
             job_model=job_model,
             interval=JobExecutionType.TYPE_IMMEDIATELY,
@@ -2133,7 +2124,7 @@ class ScheduledJobTest(
         )
         ScheduledJob.objects.create(
             name="test2",
-            task="nautobot.extras.jobs.scheduled_job_handler",
+            task="pass.TestPass",
             job_class=job_model.class_path,
             job_model=job_model,
             interval=JobExecutionType.TYPE_IMMEDIATELY,
@@ -2143,7 +2134,7 @@ class ScheduledJobTest(
         )
         ScheduledJob.objects.create(
             name="test3",
-            task="nautobot.extras.jobs.scheduled_job_handler",
+            task="pass.TestPass",
             job_class=job_model.class_path,
             job_model=job_model,
             interval=JobExecutionType.TYPE_IMMEDIATELY,
@@ -2152,17 +2143,26 @@ class ScheduledJobTest(
             start_time=now(),
         )
 
+    # TODO: Unskip after resolving #2908, #2909
+    @skip("DRF's built-in OrderingFilter triggering natural key attribute error in our base")
+    def test_list_objects_ascending_ordered(self):
+        pass
+
+    @skip("DRF's built-in OrderingFilter triggering natural key attribute error in our base")
+    def test_list_objects_descending_ordered(self):
+        pass
+
 
 class JobApprovalTest(APITestCase):
     @classmethod
     def setUpTestData(cls):
         cls.additional_user = User.objects.create(username="user1", is_active=True)
-        cls.job_model = Job.objects.get_for_class_path("local/test_pass/TestPass")
+        cls.job_model = Job.objects.get_for_class_path("pass.TestPass")
         cls.job_model.enabled = True
         cls.job_model.save()
         cls.scheduled_job = ScheduledJob.objects.create(
             name="test",
-            task="nautobot.extras.jobs.scheduled_job_handler",
+            task="pass.TestPass",
             job_class=cls.job_model.class_path,
             job_model=cls.job_model,
             interval=JobExecutionType.TYPE_IMMEDIATELY,
@@ -2170,6 +2170,19 @@ class JobApprovalTest(APITestCase):
             approval_required=True,
             start_time=now(),
         )
+        cls.dryrun_job_model = Job.objects.get_for_class_path("dry_run.TestDryRun")
+        cls.dryrun_job_model.enabled = True
+        cls.dryrun_job_model.save()
+        cls.dryrun_scheduled_job = ScheduledJob.objects.create(
+            name="test",
+            task="dry_run.TestDryRun",
+            job_class=cls.dryrun_job_model.class_path,
+            job_model=cls.dryrun_job_model,
+            interval=JobExecutionType.TYPE_IMMEDIATELY,
+            user=cls.additional_user,
+            approval_required=True,
+            start_time=now(),
+        )
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_approve_job_anonymous(self):
@@ -2203,7 +2216,7 @@ class JobApprovalTest(APITestCase):
         self.add_permissions("extras.approve_job", "extras.view_scheduledjob", "extras.change_scheduledjob")
         scheduled_job = ScheduledJob.objects.create(
             name="test",
-            task="nautobot.extras.jobs.scheduled_job_handler",
+            task="pass.TestPass",
             job_class=self.job_model.class_path,
             job_model=self.job_model,
             interval=JobExecutionType.TYPE_IMMEDIATELY,
@@ -2227,7 +2240,7 @@ class JobApprovalTest(APITestCase):
         self.add_permissions("extras.approve_job", "extras.view_scheduledjob", "extras.change_scheduledjob")
         scheduled_job = ScheduledJob.objects.create(
             name="test",
-            task="nautobot.extras.jobs.scheduled_job_handler",
+            task="pass.TestPass",
             job_class=self.job_model.class_path,
             job_model=self.job_model,
             interval=JobExecutionType.TYPE_FUTURE,
@@ -2245,7 +2258,7 @@ class JobApprovalTest(APITestCase):
         self.add_permissions("extras.approve_job", "extras.view_scheduledjob", "extras.change_scheduledjob")
         scheduled_job = ScheduledJob.objects.create(
             name="test",
-            task="nautobot.extras.jobs.scheduled_job_handler",
+            task="pass.TestPass",
             job_class=self.job_model.class_path,
             job_model=self.job_model,
             interval=JobExecutionType.TYPE_FUTURE,
@@ -2289,7 +2302,7 @@ class JobApprovalTest(APITestCase):
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
     def test_dry_run_job_without_permission(self):
-        url = reverse("extras-api:scheduledjob-dry-run", kwargs={"pk": self.scheduled_job.pk})
+        url = reverse("extras-api:scheduledjob-dry-run", kwargs={"pk": self.dryrun_scheduled_job.pk})
         with disable_warnings("django.request"):
             response = self.client.post(url, **self.header)
         self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
@@ -2297,29 +2310,27 @@ class JobApprovalTest(APITestCase):
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_dry_run_job_without_run_job_permission(self):
         self.add_permissions("extras.view_scheduledjob")
-        url = reverse("extras-api:scheduledjob-dry-run", kwargs={"pk": self.scheduled_job.pk})
+        url = reverse("extras-api:scheduledjob-dry-run", kwargs={"pk": self.dryrun_scheduled_job.pk})
         response = self.client.post(url, **self.header)
         self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_dry_run_job(self):
         self.add_permissions("extras.run_job", "extras.view_scheduledjob")
-        url = reverse("extras-api:scheduledjob-dry-run", kwargs={"pk": self.scheduled_job.pk})
+        url = reverse("extras-api:scheduledjob-dry-run", kwargs={"pk": self.dryrun_scheduled_job.pk})
         response = self.client.post(url, **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_dry_run_not_supported(self):
+        self.add_permissions("extras.run_job", "extras.view_scheduledjob")
+        url = reverse("extras-api:scheduledjob-dry-run", kwargs={"pk": self.scheduled_job.pk})
+        response = self.client.post(url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_405_METHOD_NOT_ALLOWED)
+
 
 class NoteTest(APIViewTestCases.APIViewTestCase):
     model = Note
-    brief_fields = [
-        "assigned_object",
-        "display",
-        "id",
-        "note",
-        "slug",
-        "url",
-        "user",
-    ]
     choices_fields = ["assigned_object_type"]
 
     @classmethod
@@ -2370,376 +2381,363 @@ class NoteTest(APIViewTestCases.APIViewTestCase):
         )
 
 
-# @skip(reason="Content Types are BROKEN")
-# class RelationshipTest(APIViewTestCases.APIViewTestCase, RequiredRelationshipTestMixin):
-#     model = Relationship
-#     brief_fields = ["display", "id", "name", "slug", "url"]
-
-#     create_data = [
-#         {
-#             "name": "Device VLANs",
-#             "slug": "device-vlans",
-#             "type": "many-to-many",
-#             "source_type": "ipam.vlan",
-#             "destination_type": "dcim.device",
-#         },
-#         {
-#             "name": "Primary VLAN",
-#             "slug": "primary-vlan",
-#             "type": "one-to-many",
-#             "source_type": "ipam.vlan",
-#             "destination_type": "dcim.device",
-#         },
-#         {
-#             "name": "Primary Interface",
-#             "slug": "primary-interface",
-#             "type": "one-to-one",
-#             "source_type": "dcim.device",
-#             "source_label": "primary interface",
-#             "destination_type": "dcim.interface",
-#             "destination_hidden": True,
-#         },
-#         {
-#             "name": "Relationship 1",
-#             "type": "one-to-one",
-#             "source_type": "dcim.device",
-#             "source_label": "primary interface",
-#             "destination_type": "dcim.interface",
-#             "destination_hidden": True,
-#         },
-#     ]
-
-#     bulk_update_data = {
-#         "source_filter": {"slug": ["some-slug"]},
-#     }
-#     choices_fields = ["destination_type", "source_type", "type", "required_on"]
-#     slug_source = "name"
-#     slugify_function = staticmethod(slugify_dashes_to_underscores)
-
-#     @classmethod
-#     def setUpTestData(cls):
-#         location_type = ContentType.objects.get_for_model(Location)
-#         device_type = ContentType.objects.get_for_model(Device)
-
-#         cls.relationships = (
-#             Relationship(
-#                 name="Related locations",
-#                 slug="related-locations",
-#                 type="symmetric-many-to-many",
-#                 source_type=location_type,
-#                 destination_type=location_type,
-#             ),
-#             Relationship(
-#                 name="Unrelated locations",
-#                 slug="unrelated-locations",
-#                 type="many-to-many",
-#                 source_type=location_type,
-#                 source_label="Other locations (from source side)",
-#                 destination_type=location_type,
-#                 destination_label="Other locations (from destination side)",
-#             ),
-#             Relationship(
-#                 name="Devices found elsewhere",
-#                 slug="devices-elsewhere",
-#                 type="many-to-many",
-#                 source_type=location_type,
-#                 destination_type=device_type,
-#             ),
-#         )
-#         for relationship in cls.relationships:
-#             relationship.validated_save()
-#         cls.lt = LocationType.objects.get(name="Campus")
-#         location_status = Status.objects.get_for_model(Location).first()
-#         cls.location = Location.objects.create(name="Location 1", status=location_status, location_type=cls.lt)
-
-#     def test_get_all_relationships_on_location(self):
-#         """Verify that all relationships are accurately represented when requested."""
-#         self.add_permissions("dcim.view_location")
-#         response = self.client.get(
-#             reverse("dcim-api:location-detail", kwargs={"pk": self.location.pk}) + "?include=relationships",
-#             **self.header,
-#         )
-#         self.assertHttpStatus(response, status.HTTP_200_OK)
-#         self.assertIn("relationships", response.data)
-#         self.assertIsInstance(response.data["relationships"], dict)
-#         self.maxDiff = None
-#         self.assertEqual(
-#             {
-#                 self.relationships[0].slug: {
-#                     "id": str(self.relationships[0].pk),
-#                     "url": (
-#                         "http://nautobot.example.com"
-#                         + reverse("extras-api:relationship-detail", kwargs={"pk": self.relationships[0].pk})
-#                     ),
-#                     "name": self.relationships[0].name,
-#                     "type": self.relationships[0].type,
-#                     "peer": {
-#                         "label": "locations",
-#                         "object_type": "dcim.location",
-#                         "objects": [],
-#                     },
-#                 },
-#                 self.relationships[1].slug: {
-#                     "id": str(self.relationships[1].pk),
-#                     "url": (
-#                         "http://nautobot.example.com"
-#                         + reverse("extras-api:relationship-detail", kwargs={"pk": self.relationships[1].pk})
-#                     ),
-#                     "name": self.relationships[1].name,
-#                     "type": self.relationships[1].type,
-#                     "destination": {
-#                         "label": self.relationships[1].source_label,  # yes -- it's a bit confusing
-#                         "object_type": "dcim.location",
-#                         "objects": [],
-#                     },
-#                     "source": {
-#                         "label": self.relationships[1].destination_label,  # yes -- it's a bit confusing
-#                         "object_type": "dcim.location",
-#                         "objects": [],
-#                     },
-#                 },
-#                 self.relationships[2].slug: {
-#                     "id": str(self.relationships[2].pk),
-#                     "url": (
-#                         "http://nautobot.example.com"
-#                         + reverse("extras-api:relationship-detail", kwargs={"pk": self.relationships[2].pk})
-#                     ),
-#                     "name": self.relationships[2].name,
-#                     "type": self.relationships[2].type,
-#                     "destination": {
-#                         "label": "devices",
-#                         "object_type": "dcim.device",
-#                         "objects": [],
-#                     },
-#                 },
-#             },
-#             response.data["relationships"],
-#         )
-
-#     def test_populate_relationship_associations_on_location_create(self):
-#         """Verify that relationship associations can be populated at instance creation time."""
-#         location_type = LocationType.objects.get(name="Campus")
-#         existing_location_1 = Location.objects.create(
-#             name="Existing Location 1",
-#             status=Status.objects.get_for_model(Location).first(),
-#             location_type=location_type,
-#         )
-#         existing_location_2 = Location.objects.create(
-#             name="Existing Location 2",
-#             status=Status.objects.get_for_model(Location).first(),
-#             location_type=location_type,
-#         )
-#         manufacturer = Manufacturer.objects.first()
-#         device_type = DeviceType.objects.create(
-#             manufacturer=manufacturer,
-#             model="device Type 1",
-#             slug="device-type-1",
-#         )
-#         device_role = Role.objects.get_for_model(Device).first()
-#         device_status = Status.objects.get_for_model(Device).first()
-#         existing_device_1 = Device.objects.create(
-#             name="existing-device-location-1",
-#             status=device_status,
-#             role=device_role,
-#             device_type=device_type,
-#             location=existing_location_1,
-#         )
-#         existing_device_2 = Device.objects.create(
-#             name="existing-device-location-2",
-#             status=device_status,
-#             role=device_role,
-#             device_type=device_type,
-#             location=existing_location_2,
-#         )
-
-#         self.add_permissions("dcim.view_location", "dcim.add_location", "extras.add_relationshipassociation")
-#         response = self.client.post(
-#             reverse("dcim-api:location-list"),
-#             data={
-#                 "name": "New location",
-#                 "status": Status.objects.get_for_model(Location).first().pk,
-#                 "location_type": location_type.pk,
-#                 "relationships": {
-#                     self.relationships[0].slug: {
-#                         "peer": {
-#                             "objects": [str(existing_location_1.pk)],
-#                         },
-#                     },
-#                     self.relationships[1].slug: {
-#                         "source": {
-#                             "objects": [str(existing_location_2.pk)],
-#                         },
-#                     },
-#                     self.relationships[2].slug: {
-#                         "destination": {
-#                             "objects": [
-#                                 {"name": "existing-device-location-1"},
-#                                 {"name": "existing-device-location-2"},
-#                             ],
-#                         },
-#                     },
-#                 },
-#             },
-#             format="json",
-#             **self.header,
-#         )
-#         self.assertHttpStatus(response, status.HTTP_201_CREATED)
-#         new_location_id = response.data["id"]
-#         # Peer case - don't distinguish source/destination
-#         self.assertTrue(
-#             RelationshipAssociation.objects.filter(
-#                 relationship=self.relationships[0],
-#                 source_type=self.relationships[0].source_type,
-#                 source_id__in=[existing_location_1.pk, new_location_id],
-#                 destination_type=self.relationships[0].destination_type,
-#                 destination_id__in=[existing_location_1.pk, new_location_id],
-#             ).exists()
-#         )
-#         self.assertTrue(
-#             RelationshipAssociation.objects.filter(
-#                 relationship=self.relationships[1],
-#                 source_type=self.relationships[1].source_type,
-#                 source_id=existing_location_2.pk,
-#                 destination_type=self.relationships[1].destination_type,
-#                 destination_id=new_location_id,
-#             ).exists()
-#         )
-#         self.assertTrue(
-#             RelationshipAssociation.objects.filter(
-#                 relationship=self.relationships[2],
-#                 source_type=self.relationships[2].source_type,
-#                 source_id=new_location_id,
-#                 destination_type=self.relationships[2].destination_type,
-#                 destination_id=existing_device_1.pk,
-#             ).exists()
-#         )
-#         self.assertTrue(
-#             RelationshipAssociation.objects.filter(
-#                 relationship=self.relationships[2],
-#                 source_type=self.relationships[2].source_type,
-#                 source_id=new_location_id,
-#                 destination_type=self.relationships[2].destination_type,
-#                 destination_id=existing_device_2.pk,
-#             ).exists()
-#         )
-
-#     def test_required_relationships(self):
-#         """
-#         1. Try creating an object when no required target object exists
-#         2. Try creating an object without specifying required target object(s)
-#         3. Try creating an object when all required data is present
-#         4. Test various bulk create/edit scenarios
-#         """
-
-#         # Parameterized tests (for creating and updating single objects):
-#         self.required_relationships_test(interact_with="api")
-
-#         # 4. Bulk create/edit tests:
-
-#         # VLAN endpoint to POST, PATCH and PUT multiple objects to:
-#         vlan_list_endpoint = reverse(get_route_for_model(VLAN, "list", api=True))
-
-#         def send_bulk_data(http_method, data):
-#             return getattr(self.client, http_method)(
-#                 vlan_list_endpoint,
-#                 data=data,
-#                 format="json",
-#                 **self.header,
-#             )
-
-#         device_status = Status.objects.get_for_model(Device).first()
-
-#         # Try deleting all devices and then creating 2 VLANs (fails):
-#         Device.objects.all().delete()
-#         response = send_bulk_data(
-#             "post",
-#             data=[
-#                 {"vid": "1", "name": "1", "status": device_status.pk},
-#                 {"vid": "2", "name": "2", "status": device_status.pk},
-#             ],
-#         )
-#         self.assertHttpStatus(response, 400)
-#         self.assertEqual(
-#             {
-#                 "relationships": {
-#                     "vlans-devices-m2m": [
-#                         "VLANs require at least one device, but no devices exist yet. "
-#                         "Create a device by posting to /api/dcim/devices/",
-#                         'You need to specify ["relationships"]["vlans-devices-m2m"]["source"]["objects"].',
-#                     ]
-#                 }
-#             },
-#             response.json(),
-#         )
-
-#         # Create test device for association
-#         device_for_association = test_views.create_test_device("VLAN Required Device")
-#         required_relationship_json = {"vlans-devices-m2m": {"source": {"objects": [str(device_for_association.id)]}}}
-#         expected_error_json = {
-#             "relationships": {
-#                 "vlans-devices-m2m": [
-#                     'You need to specify ["relationships"]["vlans-devices-m2m"]["source"]["objects"].'
-#                 ]
-#             }
-#         }
-
-#         # Test POST, PATCH and PUT
-#         for method in ["post", "patch", "put"]:
-#             if method == "post":
-#                 vlan1_json_data = {
-#                     "vid": "1",
-#                     "name": "1",
-#                     "status": device_status.pk,
-#                 }
-#                 vlan2_json_data = {
-#                     "vid": "2",
-#                     "name": "2",
-#                     "status": device_status.pk,
-#                 }
-#             else:
-#                 vlan1, vlan2 = VLANFactory.create_batch(2)
-#                 vlan1_json_data = {"status": device_status.pk, "id": str(vlan1.id)}
-#                 # Add required fields for PUT method:
-#                 if method == "put":
-#                     vlan1_json_data.update({"vid": vlan1.vid, "name": vlan1.name})
-
-#                 vlan2_json_data = {"status": device_status.pk, "id": str(vlan2.id)}
-#                 # Add required fields for PUT method:
-#                 if method == "put":
-#                     vlan2_json_data.update({"vid": vlan2.vid, "name": vlan2.name})
-
-#             # Try method without specifying required relationships for either vlan1 or vlan2 (fails)
-#             json_data = [vlan1_json_data, vlan2_json_data]
-#             response = send_bulk_data(method, json_data)
-#             self.assertHttpStatus(response, 400)
-#             self.assertEqual(response.json(), expected_error_json)
-
-#             # Try method specifying required relationships for just vlan1 (fails)
-#             vlan1_json_data["relationships"] = required_relationship_json
-#             json_data = [vlan1_json_data, vlan2_json_data]
-#             response = send_bulk_data(method, json_data)
-#             self.assertHttpStatus(response, 400)
-#             self.assertEqual(response.json(), expected_error_json)
-
-#             # Try method specifying required relationships for both vlan1 and vlan2 (succeeds)
-#             vlan2_json_data["relationships"] = required_relationship_json
-#             json_data = [vlan1_json_data, vlan2_json_data]
-#             response = send_bulk_data(method, json_data)
-#             if method == "post":
-#                 self.assertHttpStatus(response, 201)
-#             else:
-#                 self.assertHttpStatus(response, 200)
-
-#             # Check the relationship associations were actually created
-#             for vlan in response.json():
-#                 associated_device = vlan["relationships"]["vlans-devices-m2m"]["source"]["objects"][0]
-#                 self.assertEqual(str(device_for_association.id), associated_device["id"])
-
-
-@skip(reason="Content Types are BROKEN")
+class RelationshipTest(APIViewTestCases.APIViewTestCase, RequiredRelationshipTestMixin):
+    model = Relationship
+
+    create_data = [
+        {
+            "label": "Device VLANs",
+            "key": "device_vlans",
+            "type": "many-to-many",
+            "source_type": "ipam.vlan",
+            "destination_type": "dcim.device",
+        },
+        {
+            "label": "Primary VLAN",
+            "key": "primary_vlan",
+            "type": "one-to-many",
+            "source_type": "ipam.vlan",
+            "destination_type": "dcim.device",
+        },
+        {
+            "label": "Primary Interface",
+            "key": "primary_interface",
+            "type": "one-to-one",
+            "source_type": "dcim.device",
+            "source_label": "primary interface",
+            "destination_type": "dcim.interface",
+            "destination_hidden": True,
+        },
+        {
+            "label": "Relationship 1",
+            "type": "one-to-one",
+            "source_type": "dcim.device",
+            "source_label": "primary interface",
+            "destination_type": "dcim.interface",
+            "destination_hidden": True,
+        },
+    ]
+
+    bulk_update_data = {
+        "source_filter": {"slug": ["some-slug"]},
+    }
+    choices_fields = ["destination_type", "source_type", "type", "required_on"]
+    slug_source = "label"
+    slugify_function = staticmethod(slugify_dashes_to_underscores)
+
+    @classmethod
+    def setUpTestData(cls):
+        location_type = ContentType.objects.get_for_model(Location)
+        device_type = ContentType.objects.get_for_model(Device)
+
+        cls.relationships = (
+            Relationship(
+                label="Related locations",
+                key="related_locations",
+                type="symmetric-many-to-many",
+                source_type=location_type,
+                destination_type=location_type,
+            ),
+            Relationship(
+                label="Unrelated locations",
+                key="unrelated_locations",
+                type="many-to-many",
+                source_type=location_type,
+                source_label="Other locations (from source side)",
+                destination_type=location_type,
+                destination_label="Other locations (from destination side)",
+            ),
+            Relationship(
+                label="Devices found elsewhere",
+                key="devices_elsewhere",
+                type="many-to-many",
+                source_type=location_type,
+                destination_type=device_type,
+            ),
+        )
+        for relationship in cls.relationships:
+            relationship.validated_save()
+        cls.lt = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        cls.location = Location.objects.create(name="Location 1", status=location_status, location_type=cls.lt)
+
+    def test_get_all_relationships_on_location(self):
+        """Verify that all relationships are accurately represented when requested."""
+        self.add_permissions("dcim.view_location")
+        response = self.client.get(
+            reverse("dcim-api:location-detail", kwargs={"pk": self.location.pk}) + "?include=relationships",
+            **self.header,
+        )
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertIn("relationships", response.data)
+        self.assertIsInstance(response.data["relationships"], dict)
+        self.maxDiff = None
+        self.assertEqual(
+            {
+                self.relationships[0].key: {
+                    "id": str(self.relationships[0].pk),
+                    "url": self.absolute_api_url(self.relationships[0]),
+                    "label": self.relationships[0].label,
+                    "type": self.relationships[0].type,
+                    "peer": {
+                        "label": "locations",
+                        "object_type": "dcim.location",
+                        "objects": [],
+                    },
+                },
+                self.relationships[1].key: {
+                    "id": str(self.relationships[1].pk),
+                    "url": self.absolute_api_url(self.relationships[1]),
+                    "label": self.relationships[1].label,
+                    "type": self.relationships[1].type,
+                    "destination": {
+                        "label": self.relationships[1].source_label,  # yes -- it's a bit confusing
+                        "object_type": "dcim.location",
+                        "objects": [],
+                    },
+                    "source": {
+                        "label": self.relationships[1].destination_label,  # yes -- it's a bit confusing
+                        "object_type": "dcim.location",
+                        "objects": [],
+                    },
+                },
+                self.relationships[2].key: {
+                    "id": str(self.relationships[2].pk),
+                    "url": self.absolute_api_url(self.relationships[2]),
+                    "label": self.relationships[2].label,
+                    "type": self.relationships[2].type,
+                    "destination": {
+                        "label": "devices",
+                        "object_type": "dcim.device",
+                        "objects": [],
+                    },
+                },
+            },
+            response.data["relationships"],
+        )
+
+    def test_populate_relationship_associations_on_location_create(self):
+        """Verify that relationship associations can be populated at instance creation time."""
+        location_type = LocationType.objects.get(name="Campus")
+        existing_location_1 = Location.objects.create(
+            name="Existing Location 1",
+            status=Status.objects.get_for_model(Location).first(),
+            location_type=location_type,
+        )
+        existing_location_2 = Location.objects.create(
+            name="Existing Location 2",
+            status=Status.objects.get_for_model(Location).first(),
+            location_type=location_type,
+        )
+        manufacturer = Manufacturer.objects.first()
+        device_type = DeviceType.objects.create(
+            manufacturer=manufacturer,
+            model="device Type 1",
+            slug="device-type-1",
+        )
+        device_role = Role.objects.get_for_model(Device).first()
+        device_status = Status.objects.get_for_model(Device).first()
+        existing_device_1 = Device.objects.create(
+            name="existing-device-location-1",
+            status=device_status,
+            role=device_role,
+            device_type=device_type,
+            location=existing_location_1,
+        )
+        existing_device_2 = Device.objects.create(
+            name="existing-device-location-2",
+            status=device_status,
+            role=device_role,
+            device_type=device_type,
+            location=existing_location_2,
+        )
+
+        self.add_permissions("dcim.view_location", "dcim.add_location", "extras.add_relationshipassociation")
+        response = self.client.post(
+            reverse("dcim-api:location-list"),
+            data={
+                "name": "New location",
+                "status": Status.objects.get_for_model(Location).first().pk,
+                "location_type": location_type.pk,
+                "relationships": {
+                    self.relationships[0].key: {
+                        "peer": {
+                            "objects": [str(existing_location_1.pk)],
+                        },
+                    },
+                    self.relationships[1].key: {
+                        "source": {
+                            "objects": [str(existing_location_2.pk)],
+                        },
+                    },
+                    self.relationships[2].key: {
+                        "destination": {
+                            "objects": [
+                                {"name": "existing-device-location-1"},
+                                {"name": "existing-device-location-2"},
+                            ],
+                        },
+                    },
+                },
+            },
+            format="json",
+            **self.header,
+        )
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        new_location_id = response.data["id"]
+        # Peer case - don't distinguish source/destination
+        self.assertTrue(
+            RelationshipAssociation.objects.filter(
+                relationship=self.relationships[0],
+                source_type=self.relationships[0].source_type,
+                source_id__in=[existing_location_1.pk, new_location_id],
+                destination_type=self.relationships[0].destination_type,
+                destination_id__in=[existing_location_1.pk, new_location_id],
+            ).exists()
+        )
+        self.assertTrue(
+            RelationshipAssociation.objects.filter(
+                relationship=self.relationships[1],
+                source_type=self.relationships[1].source_type,
+                source_id=existing_location_2.pk,
+                destination_type=self.relationships[1].destination_type,
+                destination_id=new_location_id,
+            ).exists()
+        )
+        self.assertTrue(
+            RelationshipAssociation.objects.filter(
+                relationship=self.relationships[2],
+                source_type=self.relationships[2].source_type,
+                source_id=new_location_id,
+                destination_type=self.relationships[2].destination_type,
+                destination_id=existing_device_1.pk,
+            ).exists()
+        )
+        self.assertTrue(
+            RelationshipAssociation.objects.filter(
+                relationship=self.relationships[2],
+                source_type=self.relationships[2].source_type,
+                source_id=new_location_id,
+                destination_type=self.relationships[2].destination_type,
+                destination_id=existing_device_2.pk,
+            ).exists()
+        )
+
+    def test_required_relationships(self):
+        """
+        1. Try creating an object when no required target object exists
+        2. Try creating an object without specifying required target object(s)
+        3. Try creating an object when all required data is present
+        4. Test various bulk create/edit scenarios
+        """
+
+        # Parameterized tests (for creating and updating single objects):
+        self.required_relationships_test(interact_with="api")
+
+        # 4. Bulk create/edit tests:
+
+        # VLAN endpoint to POST, PATCH and PUT multiple objects to:
+        vlan_list_endpoint = reverse(get_route_for_model(VLAN, "list", api=True))
+
+        def send_bulk_data(http_method, data):
+            return getattr(self.client, http_method)(
+                vlan_list_endpoint,
+                data=data,
+                format="json",
+                **self.header,
+            )
+
+        device_status = Status.objects.get_for_model(Device).first()
+
+        # Try deleting all devices and then creating 2 VLANs (fails):
+        Device.objects.all().delete()
+        response = send_bulk_data(
+            "post",
+            data=[
+                {"vid": "1", "name": "1", "status": device_status.pk},
+                {"vid": "2", "name": "2", "status": device_status.pk},
+            ],
+        )
+        self.assertHttpStatus(response, 400)
+        self.assertEqual(
+            {
+                "relationships": {
+                    "vlans_devices_m2m": [
+                        "VLANs require at least one device, but no devices exist yet. "
+                        "Create a device by posting to /api/dcim/devices/",
+                        'You need to specify ["relationships"]["vlans_devices_m2m"]["source"]["objects"].',
+                    ]
+                }
+            },
+            response.json(),
+        )
+
+        # Create test device for association
+        device_for_association = test_views.create_test_device("VLAN Required Device")
+        required_relationship_json = {"vlans_devices_m2m": {"source": {"objects": [str(device_for_association.id)]}}}
+        expected_error_json = {
+            "relationships": {
+                "vlans_devices_m2m": [
+                    'You need to specify ["relationships"]["vlans_devices_m2m"]["source"]["objects"].'
+                ]
+            }
+        }
+
+        # Test POST, PATCH and PUT
+        for method in ["post", "patch", "put"]:
+            if method == "post":
+                vlan1_json_data = {
+                    "vid": "1",
+                    "name": "1",
+                    "status": device_status.pk,
+                }
+                vlan2_json_data = {
+                    "vid": "2",
+                    "name": "2",
+                    "status": device_status.pk,
+                }
+            else:
+                vlan1, vlan2 = VLANFactory.create_batch(2)
+                vlan1_json_data = {"status": device_status.pk, "id": str(vlan1.id)}
+                # Add required fields for PUT method:
+                if method == "put":
+                    vlan1_json_data.update({"vid": vlan1.vid, "name": vlan1.name})
+
+                vlan2_json_data = {"status": device_status.pk, "id": str(vlan2.id)}
+                # Add required fields for PUT method:
+                if method == "put":
+                    vlan2_json_data.update({"vid": vlan2.vid, "name": vlan2.name})
+
+            # Try method without specifying required relationships for either vlan1 or vlan2 (fails)
+            json_data = [vlan1_json_data, vlan2_json_data]
+            response = send_bulk_data(method, json_data)
+            self.assertHttpStatus(response, 400)
+            self.assertEqual(response.json(), expected_error_json)
+
+            # Try method specifying required relationships for just vlan1 (fails)
+            vlan1_json_data["relationships"] = required_relationship_json
+            json_data = [vlan1_json_data, vlan2_json_data]
+            response = send_bulk_data(method, json_data)
+            self.assertHttpStatus(response, 400)
+            self.assertEqual(response.json(), expected_error_json)
+
+            # Try method specifying required relationships for both vlan1 and vlan2 (succeeds)
+            vlan2_json_data["relationships"] = required_relationship_json
+            json_data = [vlan1_json_data, vlan2_json_data]
+            response = send_bulk_data(method, json_data)
+            if method == "post":
+                self.assertHttpStatus(response, 201)
+            else:
+                self.assertHttpStatus(response, 200)
+
+            # Check the relationship associations were actually created
+            for vlan in response.json():
+                associated_device = vlan["relationships"]["vlans_devices_m2m"]["source"]["objects"][0]
+                self.assertEqual(str(device_for_association.id), associated_device["id"])
+
+
 class RelationshipAssociationTest(APIViewTestCases.APIViewTestCase):
     model = RelationshipAssociation
-    brief_fields = ["destination_id", "display", "id", "relationship", "source_id", "url"]
     choices_fields = ["destination_type", "source_type"]
 
     @classmethod
@@ -2749,8 +2747,8 @@ class RelationshipAssociationTest(APIViewTestCases.APIViewTestCase):
         cls.location_status = Status.objects.get_for_model(Location).first()
 
         cls.relationship = Relationship(
-            name="Devices found elsewhere",
-            slug="elsewhere-devices",
+            label="Devices found elsewhere",
+            key="elsewhere_devices",
             type="many-to-many",
             source_type=cls.location_type,
             destination_type=cls.device_type,
@@ -2840,8 +2838,8 @@ class RelationshipAssociationTest(APIViewTestCases.APIViewTestCase):
         """Test creation of invalid relationship association restricted by destination/source filter."""
 
         relationship = Relationship.objects.create(
-            name="Device to location Rel 1",
-            slug="device-to-location-rel-1",
+            label="Device to location Rel 1",
+            key="device_to_location_rel_1",
             source_type=self.device_type,
             source_filter={"name": [self.devices[0].name]},
             destination_type=self.location_type,
@@ -2882,7 +2880,7 @@ class RelationshipAssociationTest(APIViewTestCases.APIViewTestCase):
             self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
             self.assertEqual(
                 response.data[side],
-                [f"{field_error_name} violates {relationship.name} {side}_filter restriction"],
+                [f"{field_error_name} violates {relationship.label} {side}_filter restriction"],
             )
 
     def test_model_clean_method_is_called(self):
@@ -2910,62 +2908,37 @@ class RelationshipAssociationTest(APIViewTestCases.APIViewTestCase):
         """
         self.add_permissions("dcim.view_location")
         response = self.client.get(
-            reverse("dcim-api:location-detail", kwargs={"pk": self.locations[0].pk}) + "?include=relationships",
+            reverse("dcim-api:location-detail", kwargs={"pk": self.locations[0].pk})
+            + "?include=relationships"
+            + "&depth=1",
             **self.header,
         )
         self.assertHttpStatus(response, status.HTTP_200_OK)
         self.assertIn("relationships", response.data)
         self.assertIsInstance(response.data["relationships"], dict)
         # Ensure consistent ordering
-        response.data["relationships"][self.relationship.slug]["destination"]["objects"].sort(key=lambda v: v["name"])
+        response.data["relationships"][self.relationship.key]["destination"]["objects"].sort(key=lambda v: v["name"])
         self.maxDiff = None
-        self.assertEqual(
-            {
-                self.relationship.slug: {
-                    "id": str(self.relationship.pk),
-                    "url": (
-                        "http://nautobot.example.com"
-                        + reverse("extras-api:relationship-detail", kwargs={"pk": self.relationship.pk})
-                    ),
-                    "name": self.relationship.name,
-                    "type": "many-to-many",
-                    "destination": {
-                        "label": "devices",
-                        "object_type": "dcim.device",
-                        "objects": [
-                            {
-                                "id": str(self.devices[0].pk),
-                                "url": (
-                                    "http://nautobot.example.com"
-                                    + reverse("dcim-api:device-detail", kwargs={"pk": self.devices[0].pk})
-                                ),
-                                "display": self.devices[0].display,
-                                "name": self.devices[0].name,
-                            },
-                            {
-                                "id": str(self.devices[1].pk),
-                                "url": (
-                                    "http://nautobot.example.com"
-                                    + reverse("dcim-api:device-detail", kwargs={"pk": self.devices[1].pk})
-                                ),
-                                "display": self.devices[1].display,
-                                "name": self.devices[1].name,
-                            },
-                            {
-                                "id": str(self.devices[2].pk),
-                                "url": (
-                                    "http://nautobot.example.com"
-                                    + reverse("dcim-api:device-detail", kwargs={"pk": self.devices[2].pk})
-                                ),
-                                "display": self.devices[2].display,
-                                "name": self.devices[2].name,
-                            },
-                        ],
-                    },
-                },
-            },
-            response.data["relationships"],
-        )
+        relationship_data = response.data["relationships"][self.relationship.key]
+        self.assertEqual(relationship_data["id"], str(self.relationship.pk))
+        self.assertEqual(relationship_data["url"], self.absolute_api_url(self.relationship))
+        self.assertEqual(relationship_data["label"], self.relationship.label)
+        self.assertEqual(relationship_data["type"], "many-to-many")
+        self.assertEqual(relationship_data["destination"]["label"], "devices")
+        self.assertEqual(relationship_data["destination"]["object_type"], "dcim.device")
+
+        objects = response.data["relationships"][self.relationship.key]["destination"]["objects"]
+        for i, obj in enumerate(objects):
+            self.assertEqual(obj["id"], str(self.devices[i].pk))
+            self.assertEqual(obj["url"], self.absolute_api_url(self.devices[i]))
+            self.assertEqual(
+                obj["display"],
+                self.devices[i].display,
+            )
+            self.assertEqual(
+                obj["name"],
+                self.devices[i].name,
+            )
 
     def test_update_association_data_on_location(self):
         """
@@ -3027,21 +3000,21 @@ class RelationshipAssociationTest(APIViewTestCases.APIViewTestCase):
 
         with self.subTest("Error handling: wrong relationship"):
             Relationship.objects.create(
-                name="Device-to-Device",
-                slug="device-to-device",
+                label="Device-to-Device",
+                key="device_to_device",
                 source_type=self.device_type,
                 destination_type=self.device_type,
                 type=RelationshipTypeChoices.TYPE_ONE_TO_ONE,
             )
             response = self.client.patch(
                 url,
-                {"relationships": {"device-to-device": {"peer": {"objects": []}}}},
+                {"relationships": {"device_to_device": {"peer": {"objects": []}}}},
                 format="json",
                 **self.header,
             )
             self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
             self.assertEqual(
-                str(response.data["relationships"][0]), '"device-to-device" is not a relationship on dcim.Location'
+                str(response.data["relationships"][0]), '"device_to_device" is not a relationship on dcim.Location'
             )
             self.assertEqual(3, RelationshipAssociation.objects.filter(relationship=self.relationship).count())
             for association in self.associations:
@@ -3050,7 +3023,7 @@ class RelationshipAssociationTest(APIViewTestCases.APIViewTestCase):
         with self.subTest("Error handling: wrong relationship side"):
             response = self.client.patch(
                 url,
-                {"relationships": {self.relationship.slug: {"source": {"objects": []}}}},
+                {"relationships": {self.relationship.key: {"source": {"objects": []}}}},
                 format="json",
                 **self.header,
             )
@@ -3068,7 +3041,7 @@ class RelationshipAssociationTest(APIViewTestCases.APIViewTestCase):
                 url,
                 {
                     "relationships": {
-                        self.relationship.slug: {
+                        self.relationship.key: {
                             "destination": {
                                 "objects": [
                                     # remove devices[0] by omission
@@ -3095,7 +3068,6 @@ class RelationshipAssociationTest(APIViewTestCases.APIViewTestCase):
 
 class SecretTest(APIViewTestCases.APIViewTestCase):
     model = Secret
-    brief_fields = ["display", "id", "name", "url"]
     bulk_update_data = {}
 
     create_data = [
@@ -3146,10 +3118,50 @@ class SecretTest(APIViewTestCases.APIViewTestCase):
         for secret in secrets:
             secret.validated_save()
 
+    def test_secret_check(self):
+        """
+        Ensure that we can check the validity of a secret.
+        """
+
+        with self.subTest("Secret is not accessible"):
+            test_secret = Secret.objects.create(
+                name="secret-check-test-not-accessible",
+                provider="text-file",
+                parameters={"path": "/tmp/does-not-matter"},
+            )
+            response = self.client.get(reverse("extras-api:secret-check", kwargs={"pk": test_secret.pk}), **self.header)
+            self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
+
+        self.add_permissions("extras.view_secret")
+
+        with self.subTest("Secret check successful"):
+            with tempfile.NamedTemporaryFile() as secret_file:
+                secret_file.write(b"HELLO WORLD")
+                test_secret = Secret.objects.create(
+                    name="secret-check-test-accessible",
+                    provider="text-file",
+                    parameters={"path": secret_file.name},
+                )
+                response = self.client.get(
+                    reverse("extras-api:secret-check", kwargs={"pk": test_secret.pk}), **self.header
+                )
+                self.assertHttpStatus(response, status.HTTP_200_OK)
+                self.assertEqual(response.data["result"], True)
+
+        with self.subTest("Secret check failed"):
+            test_secret = Secret.objects.create(
+                name="secret-check-test-failed",
+                provider="text-file",
+                parameters={"path": "/tmp/does-not-exist"},
+            )
+            response = self.client.get(reverse("extras-api:secret-check", kwargs={"pk": test_secret.pk}), **self.header)
+            self.assertHttpStatus(response, status.HTTP_200_OK)
+            self.assertEqual(response.data["result"], False)
+            self.assertIn("SecretValueNotFoundError", response.data["message"])
+
 
 class SecretsGroupTest(APIViewTestCases.APIViewTestCase):
     model = SecretsGroup
-    brief_fields = ["display", "id", "name", "url"]
     bulk_update_data = {}
 
     @classmethod
@@ -3200,7 +3212,6 @@ class SecretsGroupTest(APIViewTestCases.APIViewTestCase):
 
 class SecretsGroupAssociationTest(APIViewTestCases.APIViewTestCase):
     model = SecretsGroupAssociation
-    brief_fields = ["access_type", "display", "id", "secret", "secret_type", "url"]
     bulk_update_data = {}
     choices_fields = ["access_type", "secret_type"]
 
@@ -3267,7 +3278,6 @@ class SecretsGroupAssociationTest(APIViewTestCases.APIViewTestCase):
 
 class StatusTest(APIViewTestCases.APIViewTestCase):
     model = Status
-    brief_fields = ["display", "id", "name", "url"]
     bulk_update_data = {
         "color": "000000",
     }
@@ -3298,7 +3308,6 @@ class StatusTest(APIViewTestCases.APIViewTestCase):
 
 class TagTest(APIViewTestCases.APIViewTestCase):
     model = Tag
-    brief_fields = ["color", "display", "id", "name", "slug", "url"]
     create_data = [
         {"name": "Tag 4", "slug": "tag-4", "content_types": [Location._meta.label_lower]},
         {"name": "Tag 5", "slug": "tag-5", "content_types": [Location._meta.label_lower]},
@@ -3382,7 +3391,6 @@ class TagTest(APIViewTestCases.APIViewTestCase):
 
 class WebhookTest(APIViewTestCases.APIViewTestCase):
     model = Webhook
-    brief_fields = ["display", "id", "name", "url"]
     create_data = [
         {
             "content_types": ["dcim.consoleport"],
@@ -3611,7 +3619,6 @@ class WebhookTest(APIViewTestCases.APIViewTestCase):
 
 class RoleTest(APIViewTestCases.APIViewTestCase):
     model = Role
-    brief_fields = ["display", "id", "name", "url"]
     bulk_update_data = {
         "color": "000000",
     }