nautobot 2.0.4__py3-none-any.whl → 2.1.0b1__py3-none-any.whl

nautobot/core/tests/test_api.py

@@ -1,4 +1,3 @@
-from copy import deepcopy
 import csv
 from io import BytesIO, StringIO
 import json
@@ -6,6 +5,7 @@ from unittest import skip
 
 from django.contrib.contenttypes.models import ContentType
 from django.conf import settings
+from django.contrib.auth import get_user_model
 from django.test import RequestFactory, override_settings, TestCase
 from django.urls import reverse
 
@@ -29,6 +29,9 @@ from nautobot.ipam import models as ipam_models
 from nautobot.ipam.api import serializers as ipam_serializers
 
 
+User = get_user_model()
+
+
 class AppTest(testing.APITestCase):
     def test_root(self):
         url = reverse("api-root")
@@ -73,6 +76,9 @@ class APIDocsTestCase(TestCase):
         self.cf_text.save()
 
     def test_api_docs(self):
+        user = User.objects.create_user(username="nautobotuser")
+        self.client.force_login(user)
+
         url = reverse("api_docs")
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200)
@@ -183,17 +189,6 @@ class APIVersioningTestCase(testing.APITestCase):
     Testing our custom API versioning, NautobotAPIVersioning.
     """
 
-    OVERRIDE_REST_FRAMEWORK = deepcopy(settings.REST_FRAMEWORK)
-    # For Nautobot 2.0, the default/only supported API version is 2.0, which limits our ability to test with multiple
-    # or min/max versions. For test purposes we force there to be some extra versions available.
-    EXTRA_ALLOWED_VERSIONS = [
-        f"{settings.VERSION_MAJOR - 1}.99",
-        *settings.REST_FRAMEWORK["ALLOWED_VERSIONS"],
-        f"{settings.VERSION_MAJOR}.{settings.VERSION_MINOR + 1}",
-    ]
-    OVERRIDE_REST_FRAMEWORK["ALLOWED_VERSIONS"] = EXTRA_ALLOWED_VERSIONS
-    OVERRIDE_REST_FRAMEWORK["DEFAULT_VERSION"] = EXTRA_ALLOWED_VERSIONS[-1]
-
     def test_default_version(self):
         """Test that a request with no specific API version gets the default version, which is the current version."""
         url = reverse("api-root")
@@ -203,13 +198,6 @@ class APIVersioningTestCase(testing.APITestCase):
         self.assertEqual(response["API-Version"], api_settings.DEFAULT_VERSION)
         self.assertEqual(response["API-Version"], f"{settings.VERSION_MAJOR}.{settings.VERSION_MINOR}")
 
-        with override_settings(REST_FRAMEWORK=self.OVERRIDE_REST_FRAMEWORK):
-            response = self.client.get(url, **self.header)
-            self.assertHttpStatus(response, 200)
-            self.assertIn("API-Version", response)
-            self.assertEqual(response["API-Version"], self.OVERRIDE_REST_FRAMEWORK["DEFAULT_VERSION"])
-            self.assertEqual(response["API-Version"], f"{settings.VERSION_MAJOR}.{settings.VERSION_MINOR + 1}")
-
     def test_allowed_versions(self):
         """Test that all expected versions are supported."""
         for minor_version in range(0, settings.VERSION_MINOR + 1):
@@ -237,7 +225,7 @@ class APIVersioningTestCase(testing.APITestCase):
         self.assertEqual(response["API-Version"], default_version)
 
         max_version = api_settings.ALLOWED_VERSIONS[-1]
-        self.set_api_version(min_version)
+        self.set_api_version(max_version)
         response = self.client.get(url, **self.header)
         self.assertHttpStatus(response, 200)
         self.assertIn("API-Version", response)
@@ -250,29 +238,6 @@ class APIVersioningTestCase(testing.APITestCase):
         for version in api_settings.ALLOWED_VERSIONS:
             self.assertIn(version, response.data["detail"])
 
-        # Also test with explicitly added additional allowed versions
-        with override_settings(REST_FRAMEWORK=self.OVERRIDE_REST_FRAMEWORK):
-            min_version = self.EXTRA_ALLOWED_VERSIONS[0]
-            self.set_api_version(min_version)
-            response = self.client.get(url, **self.header)
-            self.assertHttpStatus(response, 200)
-            self.assertIn("API-Version", response)
-            self.assertEqual(response["API-Version"], min_version)
-
-            max_version = self.EXTRA_ALLOWED_VERSIONS[-1]
-            self.set_api_version(max_version)
-            response = self.client.get(url, **self.header)
-            self.assertHttpStatus(response, 200)
-            self.assertIn("API-Version", response)
-            self.assertEqual(response["API-Version"], max_version)
-
-            invalid_version = "0.0"
-            self.set_api_version(invalid_version)
-            response = self.client.get(url, **self.header)
-            self.assertHttpStatus(response, 406)  # Not Acceptable
-            for version in self.EXTRA_ALLOWED_VERSIONS:
-                self.assertIn(version, response.data["detail"])
-
     def test_query_version(self):
         """Test that the API version can be specified via a query parameter."""
         url = reverse("api-root")
@@ -301,33 +266,12 @@ class APIVersioningTestCase(testing.APITestCase):
         for version in api_settings.ALLOWED_VERSIONS:
             self.assertIn(version, response.data["detail"])
 
-        # Also test with explicitly added additional allowed versions
-        with override_settings(REST_FRAMEWORK=self.OVERRIDE_REST_FRAMEWORK):
-            min_version = self.EXTRA_ALLOWED_VERSIONS[0]
-            response = self.client.get(f"{url}?api_version={min_version}", **self.header)
-            self.assertHttpStatus(response, 200)
-            self.assertIn("API-Version", response)
-            self.assertEqual(response["API-Version"], min_version)
-
-            max_version = self.EXTRA_ALLOWED_VERSIONS[-1]
-            response = self.client.get(f"{url}?api_version={max_version}", **self.header)
-            self.assertHttpStatus(response, 200)
-            self.assertIn("API-Version", response)
-            self.assertEqual(response["API-Version"], max_version)
-
-            invalid_version = "0.0"
-            response = self.client.get(f"{url}?api_version={invalid_version}", **self.header)
-            self.assertHttpStatus(response, 404)
-            for version in self.EXTRA_ALLOWED_VERSIONS:
-                self.assertIn(version, response.data["detail"])
-
-    @override_settings(REST_FRAMEWORK=OVERRIDE_REST_FRAMEWORK)
     def test_header_and_query_version(self):
         """Test the behavior when the API version is specified in both the Accept header *and* a query parameter."""
         url = reverse("api-root")
 
-        min_version = self.EXTRA_ALLOWED_VERSIONS[0]
-        max_version = self.EXTRA_ALLOWED_VERSIONS[-1]
+        min_version = api_settings.ALLOWED_VERSIONS[0]
+        max_version = api_settings.ALLOWED_VERSIONS[-1]
         # Specify same version both as Accept header and as query parameter (valid)
         self.set_api_version(max_version)
         response = self.client.get(f"{url}?api_version={max_version}", **self.header)
@@ -873,6 +817,9 @@ class APIOrderingTestCase(testing.APITestCase):
 class NewUIGetMenuAPIViewTestCase(testing.APITestCase):
     def test_get_menu(self):
         """Asset response from new ui nav menu api returns a well formatted registry["new_ui_nav_menu"] expected by nautobot-ui."""
+        self.user.is_superuser = True
+        self.user.save()
+
         url = reverse("ui-api:get-menu")
         response = self.client.get(url, **self.header)
         expected_response = {
@@ -975,6 +922,7 @@ class NewUIGetMenuAPIViewTestCase(testing.APITestCase):
                 },
             },
         }
+
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.data, expected_response)
 

nautobot/core/tests/test_filters.py

@@ -1,3 +1,5 @@
+import datetime
+
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
@@ -9,6 +11,8 @@ from django.test.utils import isolate_apps
 import django_filters
 from tree_queries.models import TreeNodeForeignKey
 
+from nautobot.circuits.filters import CircuitFilterSet
+from nautobot.circuits.models import Circuit, CircuitType, Provider
 from nautobot.core import filters, testing
 from nautobot.core.models import fields as core_fields
 from nautobot.core.utils import lookup
@@ -1450,6 +1454,129 @@ class SearchFilterTest(TestCase, testing.NautobotTestCaseMixin):
                 q = filters.SearchFilter(filter_predicates={"asn": ["icontains"]})
 
 
+class LookupIsNullTest(TestCase, testing.NautobotTestCaseMixin):
+    """
+    Validate isnull is properly applied and filtering.
+    """
+
+    platform_queryset = dcim_models.Platform.objects.all()
+    platform_filterset = dcim_filters.PlatformFilterSet
+    circuit_queryset = Circuit.objects.all()
+    circuit_filterset = CircuitFilterSet
+    device_queryset = dcim_models.Device.objects.all()
+    device_filterset = dcim_filters.DeviceFilterSet
+
+    @classmethod
+    def setUpTestData(cls):
+        location_type = dcim_models.LocationType.objects.create(name="Location Type 1")
+        location_status = extras_models.Status.objects.get_for_model(dcim_models.Location).first()
+        location = dcim_models.Location.objects.create(
+            name="Location 1",
+            location_type=location_type,
+            status=location_status,
+        )
+        manufacturer = dcim_models.Manufacturer.objects.create(name="Manufacturer 1")
+        dcim_models.Platform.objects.create(name="Platform 1")
+        platform = dcim_models.Platform.objects.create(name="Platform 2", manufacturer=manufacturer)
+
+        device_type = dcim_models.DeviceType.objects.create(
+            manufacturer=manufacturer,
+            model="Model 1",
+            is_full_depth=True,
+        )
+        device_role = extras_models.Role.objects.create(name="Active Test")
+        device_role.content_types.add(ContentType.objects.get_for_model(dcim_models.Device))
+
+        device_status = extras_models.Status.objects.get_for_model(dcim_models.Device).first()
+
+        dcim_models.Device.objects.create(
+            name="Device 1",
+            device_type=device_type,
+            role=device_role,
+            platform=platform,
+            location=location,
+            status=device_status,
+        )
+        dcim_models.Device.objects.create(
+            device_type=device_type,
+            role=device_role,
+            platform=platform,
+            location=location,
+            status=device_status,
+        )
+
+        provider = Provider.objects.create(name="provider 1", asn=1)
+        circuit_type = CircuitType.objects.create(name="Circuit Type 1")
+        circuit_status = extras_models.Status.objects.get_for_model(dcim_models.Location).first()
+
+        Circuit.objects.create(
+            cid="Circuit 1",
+            provider=provider,
+            install_date=datetime.date(2020, 1, 1),
+            commit_rate=1000,
+            circuit_type=circuit_type,
+            status=circuit_status,
+        )
+        Circuit.objects.create(
+            cid="Circuit 2",
+            provider=provider,
+            circuit_type=circuit_type,
+            status=circuit_status,
+        )
+
+    def test_isnull_on_fk(self):
+        """Test that the `isnull` filter is applied for True and False queries on foreign key fields."""
+        params = {"manufacturer__isnull": True}
+        self.assertQuerysetEqualAndNotEmpty(
+            dcim_filters.PlatformFilterSet(params, self.platform_queryset).qs,
+            dcim_models.Platform.objects.filter(manufacturer__isnull=True),
+        )
+        params = {"manufacturer__isnull": False}
+        self.assertQuerysetEqualAndNotEmpty(
+            dcim_filters.PlatformFilterSet(params, self.platform_queryset).qs,
+            dcim_models.Platform.objects.filter(manufacturer__isnull=False),
+        )
+
+    def test_isnull_on_integer(self):
+        """Test that the `isnull` filter is applied for True and False queries on integer fields."""
+        params = {"commit_rate__isnull": True}
+        self.assertQuerysetEqualAndNotEmpty(
+            CircuitFilterSet(params, self.circuit_queryset).qs,
+            Circuit.objects.filter(commit_rate__isnull=True),
+        )
+        params = {"commit_rate__isnull": False}
+        self.assertQuerysetEqualAndNotEmpty(
+            CircuitFilterSet(params, self.circuit_queryset).qs,
+            Circuit.objects.filter(commit_rate__isnull=False),
+        )
+
+    def test_isnull_on_date(self):
+        """Test that the `isnull` filter is applied for True and False queries on datetime fields."""
+        params = {"install_date__isnull": True}
+        self.assertQuerysetEqualAndNotEmpty(
+            CircuitFilterSet(params, self.circuit_queryset).qs,
+            Circuit.objects.filter(install_date__isnull=True),
+        )
+        params = {"install_date__isnull": False}
+        self.assertQuerysetEqualAndNotEmpty(
+            CircuitFilterSet(params, self.circuit_queryset).qs,
+            Circuit.objects.filter(install_date__isnull=False),
+        )
+
+    def test_isnull_on_char(self):
+        """Test that the `isnull` filter is applied for True and False queries on char fields."""
+        params = {"name__isnull": True}
+        self.assertQuerysetEqualAndNotEmpty(
+            dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
+            dcim_models.Device.objects.filter(name__isnull=True),
+        )
+        params = {"name__isnull": False}
+        self.assertQuerysetEqualAndNotEmpty(
+            dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
+            dcim_models.Device.objects.filter(name__isnull=False),
+        )
+
+
 class FilterTypeTest(TestCase):
     client_class = testing.NautobotTestClient
 

nautobot/core/tests/test_forms.py

@@ -687,7 +687,7 @@ class DynamicFilterFormTest(TestCase):
                     ("racks", "Rack (name or ID)"),
                     ("rack_groups", "Rack groups (name or ID)"),
                     ("shipping_address", "Shipping address"),
-                    ("status", "Status"),
+                    ("status", "Status (name or ID)"),
                     ("vlans", "Tagged VLANs (VID or ID)"),
                     ("tags", "Tags"),
                     ("tenant_id", 'Tenant (ID) (deprecated, use "tenant" filter instead)'),
@@ -805,9 +805,9 @@ class DynamicFilterFormTest(TestCase):
                 },
             )
 
-        with self.subTest("Test for lookup_value with a NullBooleanField and StaticSelect2 widget"):
+        with self.subTest("Test for lookup_value with a ChoiceField and StaticSelect2 widget"):
             # If `lookup_field` value is a boolean filter and `lookup_type` lookup expr is `exact`, then
-            # `lookup_value` field should be a NullBooleanField with StaticSelect2 widget
+            # `lookup_value` field should be a ChoiceField with StaticSelect2 widget
             form = forms.DynamicFilterForm(filterset=location_filterset, data=data, prefix="form-2")
             self.assertEqual(
                 form.fields["lookup_type"].widget.attrs,
@@ -819,7 +819,7 @@ class DynamicFilterFormTest(TestCase):
                     "placeholder": None,
                 },
             )
-            self.assertIsInstance(form.fields["lookup_value"], django_forms.NullBooleanField)
+            self.assertIsInstance(form.fields["lookup_value"], django_forms.ChoiceField)
             self.assertEqual(
                 form.fields["lookup_value"].widget.attrs,
                 {"class": "form-control nautobot-select2-static lookup_value-input form-control"},

nautobot/core/tests/test_graphql.py

@@ -47,6 +47,8 @@ from nautobot.dcim.models import (
     DeviceType,
     FrontPort,
     Interface,
+    InterfaceRedundancyGroup,
+    InterfaceRedundancyGroupAssociation,
     Location,
     LocationType,
     PowerFeed,
@@ -70,7 +72,16 @@ from nautobot.extras.models import (
 )
 from nautobot.extras.registry import registry
 from nautobot.ipam.factory import VLANGroupFactory
-from nautobot.ipam.models import IPAddress, VLAN, Namespace, Prefix
+from nautobot.ipam.models import (
+    IPAddress,
+    IPAddressToInterface,
+    Namespace,
+    Prefix,
+    VLAN,
+    VRF,
+    VRFDeviceAssignment,
+    VRFPrefixAssignment,
+)
 from nautobot.users.models import ObjectPermission, Token
 from nautobot.tenancy.models import Tenant
 from nautobot.virtualization.factory import ClusterTypeFactory
@@ -834,9 +845,55 @@ class GraphQLQueryTest(TestCase):
             device=cls.device1,
             status=interface_status,
         )
+        cls.namespace = Namespace.objects.first()
+        cls.intr_group_status = Status.objects.get_for_model(InterfaceRedundancyGroup).first()
+        cls.interface_redundancy_group_1 = InterfaceRedundancyGroup.objects.create(
+            name="IRGroup 1",
+            status=cls.intr_group_status,
+        )
+        cls.interface_redundancy_group_2 = InterfaceRedundancyGroup.objects.create(
+            name="IRGroup 2",
+            status=cls.intr_group_status,
+        )
+        cls.interface_redundancy_group_3 = InterfaceRedundancyGroup.objects.create(
+            name="IRGroup 3",
+            status=cls.intr_group_status,
+        )
+        cls.irg_associations = (
+            InterfaceRedundancyGroupAssociation.objects.create(
+                interface_redundancy_group=cls.interface_redundancy_group_1,
+                interface=cls.interface11,
+                priority=123,
+            ),
+            InterfaceRedundancyGroupAssociation.objects.create(
+                interface_redundancy_group=cls.interface_redundancy_group_2,
+                interface=cls.interface12,
+                priority=456,
+            ),
+            InterfaceRedundancyGroupAssociation.objects.create(
+                interface_redundancy_group=cls.interface_redundancy_group_3,
+                interface=cls.interface11,
+                priority=789,
+            ),
+            InterfaceRedundancyGroupAssociation.objects.create(
+                interface_redundancy_group=cls.interface_redundancy_group_3,
+                interface=cls.interface12,
+                priority=789,
+            ),
+        )
+        prefixes = Prefix.objects.all()[:2]
+        cls.namespace = prefixes[0].namespace
+        vrfs = (
+            VRF.objects.create(name="VRF 1", rd="65000:100", namespace=cls.namespace),
+            VRF.objects.create(name="VRF 2", rd="65000:200", namespace=cls.namespace),
+        )
+        prefixes[0].vrfs.add(vrfs[0])
+        prefixes[0].vrfs.add(vrfs[1])
+        prefixes[1].vrfs.add(vrfs[0])
+        prefixes[1].vrfs.add(vrfs[1])
+
         cls.ip_statuses = list(Status.objects.get_for_model(IPAddress))[:2]
         cls.prefix_statuses = list(Status.objects.get_for_model(Prefix))[:2]
-        cls.namespace = Namespace.objects.first()
         cls.prefix1 = Prefix.objects.create(
             prefix="10.0.1.0/24", namespace=cls.namespace, status=cls.prefix_statuses[0]
         )
@@ -855,6 +912,10 @@ class GraphQLQueryTest(TestCase):
             tenant=cls.tenant2,
             face="rear",
         )
+        cls.device2.vrfs.add(vrfs[0])
+        cls.device2.vrfs.add(vrfs[1])
+        cls.device2.vrfs.add(vrfs[0])
+        cls.device2.vrfs.add(vrfs[1])
 
         cls.interface21 = Interface.objects.create(
             name="Int1",
@@ -1178,6 +1239,108 @@ query {
             # Assert GraphQL returned properties match those expected
             self.assertEqual(console_port_entry["connected_console_server_port"], connected_console_server_port)
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_interface_redundancy_group_associations(self):
+        """Test graphql functionality for InterfaceRedundancyGroupAssociation"""
+
+        query = """\
+query {
+    interface_redundancy_group_associations {
+        id
+        interface { id }
+        interface_redundancy_group { id }
+        priority
+    }
+}"""
+
+        result = self.execute_query(query)
+        self.assertIsNone(result.errors)
+        self.assertEqual(
+            len(InterfaceRedundancyGroupAssociation.objects.all()),
+            len(result.data["interface_redundancy_group_associations"]),
+        )
+        for association in result.data["interface_redundancy_group_associations"]:
+            association_obj = InterfaceRedundancyGroupAssociation.objects.get(id=association["id"])
+            # Assert GraphQL returned properties match those expected
+            self.assertEqual(association["interface"]["id"], str(association_obj.interface.pk))
+            self.assertEqual(
+                association["interface_redundancy_group"]["id"], str(association_obj.interface_redundancy_group.pk)
+            )
+            self.assertEqual(association["priority"], association_obj.priority)
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_ip_address_to_interface(self):
+        """Test graphql functionality for IPAddressToInterface"""
+
+        query = """\
+query {
+    ip_address_assignments {
+        id
+        interface { id }
+        vm_interface { id }
+        ip_address { id }
+    }
+}"""
+
+        result = self.execute_query(query)
+        self.assertIsNone(result.errors)
+        self.assertEqual(
+            len(IPAddressToInterface.objects.all()),
+            len(result.data["ip_address_assignments"]),
+        )
+        for association in result.data["ip_address_assignments"]:
+            association_obj = IPAddressToInterface.objects.get(id=association["id"])
+            # Assert GraphQL returned properties match those expected
+            if association_obj.interface:
+                self.assertEqual(association["interface"]["id"], str(association_obj.interface.pk))
+            else:
+                self.assertEqual(association["interface"], None)
+            if association_obj.vm_interface:
+                self.assertEqual(association["vm_interface"]["id"], str(association_obj.vm_interface.pk))
+            else:
+                self.assertEqual(association["vm_interface"], None)
+            self.assertEqual(association["ip_address"]["id"], str(association_obj.ip_address.pk))
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_vrf_assignments(self):
+        """Test graphql functionality for VRFDeviceAssignment and VRFPrefixAssignment"""
+
+        query = """\
+query {
+    vrf_device_assignments {
+        id
+        vrf { id }
+        device { id }
+    }
+    vrf_prefix_assignments {
+        id
+        vrf { id }
+        prefix { id }
+    }
+}"""
+
+        result = self.execute_query(query)
+        self.assertIsNone(result.errors)
+        self.assertEqual(
+            len(VRFDeviceAssignment.objects.all()),
+            len(result.data["vrf_device_assignments"]),
+        )
+        self.assertEqual(
+            len(VRFPrefixAssignment.objects.all()),
+            len(result.data["vrf_prefix_assignments"]),
+        )
+        for assignment in result.data["vrf_device_assignments"]:
+            assignment_obj = VRFDeviceAssignment.objects.get(id=assignment["id"])
+            # Assert GraphQL returned properties match those expected
+            self.assertEqual(assignment["vrf"]["id"], str(assignment_obj.vrf.pk))
+            self.assertEqual(assignment["device"]["id"], str(assignment_obj.device.pk))
+
+        for assignment in result.data["vrf_prefix_assignments"]:
+            assignment_obj = VRFPrefixAssignment.objects.get(id=assignment["id"])
+            # Assert GraphQL returned properties match those expected
+            self.assertEqual(assignment["vrf"]["id"], str(assignment_obj.vrf.pk))
+            self.assertEqual(assignment["prefix"]["id"], str(assignment_obj.prefix.pk))
+
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_console_server_ports_cable_peer(self):
         """Test querying console server port terminations for their cable peers"""

nautobot/core/tests/test_jobs.py

@@ -0,0 +1,112 @@
+from pathlib import Path
+
+from django.contrib.contenttypes.models import ContentType
+import yaml
+
+from nautobot.core.testing import TransactionTestCase, create_job_result_and_run_job
+from nautobot.dcim.models import DeviceType, Manufacturer
+from nautobot.extras.choices import JobResultStatusChoices, LogLevelChoices
+from nautobot.extras.models import ExportTemplate, JobLogEntry, Status
+from nautobot.users.models import ObjectPermission
+
+
+class ExportObjectListTest(TransactionTestCase):
+    """
+    Test the ExportObjectList system job.
+    """
+
+    databases = ("default", "job_logs")
+
+    def test_export_without_permission(self):
+        """Job should enforce user permissions on the content-type being asked for export."""
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs",
+            "ExportObjectList",
+            username=self.user.username,  # otherwise run_job_for_testing defaults to a superuser account
+            content_type=ContentType.objects.get_for_model(Status).pk,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        log_error = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertEqual(log_error.message, f'User "{self.user}" does not have permission to view status objects')
+        self.assertFalse(job_result.files.exists())
+
+    def test_export_with_constrained_permission(self):
+        """Job should only allow the user to export objects they have permission to view."""
+        instance1, instance2 = Status.objects.all()[:2]
+        obj_perm = ObjectPermission(
+            name="Test permission",
+            constraints={"pk": instance1.pk},
+            actions=["view"],
+        )
+        obj_perm.save()
+        obj_perm.users.add(self.user)
+        obj_perm.object_types.add(ContentType.objects.get_for_model(Status))
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs",
+            "ExportObjectList",
+            username=self.user.username,  # otherwise run_job_for_testing defaults to a superuser account
+            content_type=ContentType.objects.get_for_model(Status).pk,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertTrue(job_result.files.exists())
+        self.assertEqual(Path(job_result.files.first().file.name).name, "nautobot_statuses.csv")
+        csv_data = job_result.files.first().file.read().decode("utf-8")
+        self.assertIn(str(instance1.pk), csv_data)
+        self.assertNotIn(str(instance2.pk), csv_data)
+
+    def test_export_all_to_csv(self):
+        """By default, job should export all instances to CSV."""
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs",
+            "ExportObjectList",
+            content_type=ContentType.objects.get_for_model(Status).pk,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertTrue(job_result.files.exists())
+        self.assertEqual(Path(job_result.files.first().file.name).name, "nautobot_statuses.csv")
+        csv_data = job_result.files.first().file.read().decode("utf-8")
+        # May be more than one line per Status if they have newlines in their description strings
+        self.assertGreaterEqual(len(csv_data.split("\n")), Status.objects.count() + 1, csv_data)  # +1 for CSV header
+
+    def test_export_all_via_export_template(self):
+        """When an export-template is specified, it should be used."""
+        et = ExportTemplate.objects.create(
+            content_type=ContentType.objects.get_for_model(Status),
+            name="Simple Export Template",
+            template_code="{% for obj in queryset %}{{ obj.name }}\n{% endfor %}",
+            file_extension="txt",
+        )
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs",
+            "ExportObjectList",
+            content_type=ContentType.objects.get_for_model(Status).pk,
+            export_template=et.pk,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertTrue(job_result.files.exists())
+        self.assertEqual(Path(job_result.files.first().file.name).name, "nautobot_statuses.txt")
+        text_data = job_result.files.first().file.read().decode("utf-8")
+        self.assertEqual(len(text_data.split("\n")), Status.objects.count() + 1)
+        for status in Status.objects.iterator():
+            self.assertIn(status.name, text_data)
+
+    def test_export_devicetype_to_yaml(self):
+        """Export device-type to YAML."""
+        mfr = Manufacturer.objects.create(name="Cisco")
+        DeviceType.objects.create(
+            manufacturer=mfr,
+            model="Cisco CSR1000v",
+            u_height=0,
+        )
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs",
+            "ExportObjectList",
+            content_type=ContentType.objects.get_for_model(DeviceType).pk,
+            export_format="yaml",
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertTrue(job_result.files.exists())
+        self.assertEqual(Path(job_result.files.first().file.name).name, "nautobot_device_types.yaml")
+        yaml_data = job_result.files.first().file.read().decode("utf-8")
+        data = yaml.safe_load(yaml_data)
+        self.assertEqual(data["manufacturer"], "Cisco")

nautobot/core/tests/test_openapi.py

@@ -41,6 +41,9 @@ class OpenAPITest(TestCase):
         query_params = self.schema["paths"]["/dcim/devices/"]["get"]["parameters"]
         at_least_one_test = False
         for query_param_info in query_params:
+            if query_param_info["name"].endswith("_isnull"):
+                # The broad catch below does not apply to isnull, which will return a boolean.
+                continue
             if query_param_info["name"].startswith("created") or query_param_info["name"].startswith("last_updated"):
                 self.assertEqual("array", query_param_info["schema"]["type"])
                 self.assertEqual("string", query_param_info["schema"]["items"]["type"])
@@ -57,6 +60,9 @@ class OpenAPITest(TestCase):
         query_params = self.schema["paths"]["/dcim/devices/"]["get"]["parameters"]
         at_least_one_test = False
         for query_param_info in query_params:
+            if query_param_info["name"].endswith("_isnull"):
+                # The broad catch below does not apply to isnull, which will return a boolean.
+                continue
             if query_param_info["name"].startswith("device_redundancy_group_priority"):
                 self.assertEqual("array", query_param_info["schema"]["type"])
                 self.assertEqual("integer", query_param_info["schema"]["items"]["type"])