nautobot 2.2.9__py3-none-any.whl → 2.3.0__py3-none-any.whl

nautobot/core/testing/views.py

@@ -269,7 +269,7 @@ class ViewTestCases:
             response = self.client.get(url)
             self.assertHttpStatus(response, 200)
             response_data = response.content.decode(response.charset)
-            if type(obj) not in [extras_models.Contact, extras_models.Team]:
+            if getattr(obj, "is_contact_associable_model", False):
                 self.assertInHTML(
                     f'<a href="{obj.get_absolute_url()}#contacts" onclick="switch_tab(this.href)" aria-controls="contacts" role="tab" data-toggle="tab">Contacts</a>',
                     response_data,
@@ -288,7 +288,7 @@ class ViewTestCases:
                 response = self.client.get(url)
                 self.assertHttpStatus(response, 200)
                 response_data = response.content.decode(response.charset)
-                if type(obj) not in [extras_models.Contact, extras_models.Team]:
+                if getattr(obj, "is_contact_associable_model", False):
                     self.assertInHTML(
                         f'<a href="{obj.get_absolute_url()}#contacts" onclick="switch_tab(this.href)" aria-controls="contacts" role="tab" data-toggle="tab">Contacts</a>',
                         response_data,
@@ -467,10 +467,12 @@ class ViewTestCases:
         """
         Edit a single existing instance.
 
-        :form_data: Data to be used when updating the first existing object.
+        :update_data: Data to be used when updating the first existing object, fall back to form_data if not provided.
+        :form_data: Fall back to this data if update_data is not provided, for backward compatibility.
         """
 
         form_data = {}
+        update_data = {}
 
         def test_edit_object_without_permission(self):
             instance = self._get_queryset().first()
@@ -480,9 +482,10 @@ class ViewTestCases:
                 self.assertHttpStatus(self.client.get(self._get_url("edit", instance)), [403, 404])
 
             # Try POST without permission
+            update_data = self.update_data or self.form_data
             request = {
                 "path": self._get_url("edit", instance),
-                "data": utils.post_data(self.form_data),
+                "data": utils.post_data(update_data),
             }
             with utils.disable_warnings("django.request"):
                 self.assertHttpStatus(self.client.post(**request), [403, 404])
@@ -501,17 +504,17 @@ class ViewTestCases:
             self.assertHttpStatus(self.client.get(self._get_url("edit", instance)), 200)
 
             # Try POST with model-level permission
+            update_data = self.update_data or self.form_data
             request = {
                 "path": self._get_url("edit", instance),
-                "data": utils.post_data(self.form_data),
+                "data": utils.post_data(update_data),
             }
             self.assertHttpStatus(self.client.post(**request), 302)
-            self.assertInstanceEqual(self._get_queryset().get(pk=instance.pk), self.form_data)
+            self.assertInstanceEqual(self._get_queryset().get(pk=instance.pk), update_data)
 
             if hasattr(self.model, "to_objectchange"):
                 # Verify ObjectChange creation
                 objectchanges = lookup.get_changes_for_model(instance)
-                self.assertEqual(len(objectchanges), 1)
                 self.assertEqual(objectchanges[0].action, extras_choices.ObjectChangeActionChoices.ACTION_UPDATE)
                 # Validate if detail view exists
                 validate = URLValidator()
@@ -549,17 +552,18 @@ class ViewTestCases:
             self.assertHttpStatus(self.client.get(self._get_url("edit", instance2)), 404)
 
             # Try to edit a permitted object
+            update_data = self.update_data or self.form_data
             request = {
                 "path": self._get_url("edit", instance1),
-                "data": utils.post_data(self.form_data),
+                "data": utils.post_data(update_data),
             }
             self.assertHttpStatus(self.client.post(**request), 302)
-            self.assertInstanceEqual(self._get_queryset().get(pk=instance1.pk), self.form_data)
+            self.assertInstanceEqual(self._get_queryset().get(pk=instance1.pk), update_data)
 
             # Try to edit a non-permitted object
             request = {
                 "path": self._get_url("edit", instance2),
-                "data": utils.post_data(self.form_data),
+                "data": utils.post_data(update_data),
             }
             self.assertHttpStatus(self.client.post(**request), 404)
 
@@ -637,7 +641,6 @@ class ViewTestCases:
             if hasattr(self.model, "to_objectchange"):
                 # Verify ObjectChange creation
                 objectchanges = lookup.get_changes_for_model(instance)
-                self.assertEqual(len(objectchanges), 1)
                 self.assertEqual(objectchanges[0].action, extras_choices.ObjectChangeActionChoices.ACTION_DELETE)
 
             if hasattr(self.model, "notes") and isinstance(instance.notes, extras_querysets.NotesQuerySet):
@@ -678,7 +681,6 @@ class ViewTestCases:
             if hasattr(self.model, "to_objectchange"):
                 # Verify ObjectChange creation
                 objectchanges = lookup.get_changes_for_model(instance)
-                self.assertEqual(len(objectchanges), 1)
                 self.assertEqual(objectchanges[0].action, extras_choices.ObjectChangeActionChoices.ACTION_DELETE)
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
@@ -790,6 +792,10 @@ class ViewTestCases:
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_list_objects_filtered(self):
             instance1, instance2 = self._get_queryset().all()[:2]
+            if hasattr(self.model, "name") and instance1.name == instance2.name:
+                instance2.name += "X"
+                instance2.save()
+
             response = self.client.get(f"{self._get_url('list')}?id={instance1.pk}")
             self.assertHttpStatus(response, 200)
             content = utils.extract_page_body(response.content.decode(response.charset))
@@ -815,6 +821,10 @@ class ViewTestCases:
         def test_list_objects_unknown_filter_no_strict_filtering(self):
             """Verify that without STRICT_FILTERING, an unknown filter is ignored."""
             instance1, instance2 = self._get_queryset().all()[:2]
+            if hasattr(self.model, "name") and instance1.name == instance2.name:
+                instance2.name += "X"
+                instance2.save()
+
             with self.assertLogs("nautobot.core.filters") as cm:
                 response = self.client.get(f"{self._get_url('list')}?ice_cream_flavor=chocolate")
             filterset = self.get_filterset()
@@ -881,6 +891,9 @@ class ViewTestCases:
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_list_objects_with_constrained_permission(self):
             instance1, instance2 = self._get_queryset().all()[:2]
+            if hasattr(self.model, "name") and instance1.name == instance2.name:
+                instance2.name += "X"
+                instance2.save()
 
             # Add object-level permission
             obj_perm = users_models.ObjectPermission(
@@ -1409,7 +1422,9 @@ class ViewTestCases:
             # Try POST with model-level permission
             self.assertHttpStatus(self.client.post(self._get_url("bulk_rename"), data), 302)
             for i, instance in enumerate(self._get_queryset().filter(pk__in=pk_list)):
-                self.assertEqual(instance.name, f"{objects[i].name}X")
+                name = getattr(instance, "name")
+                expected_name = getattr(objects[i], "name") + "X"
+                self.assertEqual(name, expected_name)
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_bulk_rename_objects_with_constrained_permission(self):
@@ -1442,7 +1457,9 @@ class ViewTestCases:
             # Bulk rename permitted objects
             self.assertHttpStatus(self.client.post(self._get_url("bulk_rename"), data), 302)
             for i, instance in enumerate(self._get_queryset().filter(pk__in=pk_list)):
-                self.assertEqual(instance.name, f"{objects[i].name}X")
+                name = getattr(instance, "name")
+                expected_name = getattr(objects[i], "name") + "X"
+                self.assertEqual(name, expected_name)
 
     class PrimaryObjectViewTestCase(
         GetObjectViewTestCase,

nautobot/core/tests/integration/test_import_objects_ui.py

@@ -18,6 +18,7 @@ class ImportObjectsUITestCase(SeleniumTestCase):
         self.browser.visit(self.live_server_url)
         self.browser.links.find_by_partial_text("Organization").click()
         self.browser.links.find_by_partial_text("Locations").click()
+        self.browser.find_by_id("actions-dropdown").click()
         self.browser.find_by_id("import-button").click()
 
         # Make sure the table of fields for a Location import is populated via a few spot checks

nautobot/core/tests/integration/test_swagger.py

@@ -20,7 +20,7 @@ class SwaggerUITestCase(SeleniumTestCase):
         """Check that the dcim.location API endpoints are rendered correctly."""
         self.browser.visit(self.live_server_url + reverse("api_docs"))
         # Wait for Swagger UI to load, look for the location-list endpoint in the UI and click on it to expand it.
-        dcim_locations_list = self.browser.find_by_id("operations-dcim-dcim_locations_list", wait_time=20).first
+        dcim_locations_list = self.browser.find_by_id("operations-dcim-dcim_locations_list", wait_time=60).first
         dcim_locations_list.find_by_tag("button").first.click()
 
         # Look for the "Try it out" button and click it

nautobot/core/tests/nautobot_config.py

@@ -58,5 +58,4 @@ METRICS_ENABLED = True
 
 METRICS_AUTHENTICATED = True
 
-DYNAMIC_GROUPS_MEMBER_CACHE_TIMEOUT = 0
 CONTENT_TYPE_CACHE_TIMEOUT = 0

nautobot/core/tests/runner.py

@@ -13,9 +13,9 @@ from nautobot.core.celery import app, setup_nautobot_job_logging
 from nautobot.core.settings_funcs import parse_redis_connection
 
 
-def init_worker_with_unique_cache(counter):
+def init_worker_with_unique_cache(*args, **kwargs):
     """Extend Django's default parallel unit test setup to also ensure distinct Redis caches."""
-    _init_worker(counter)  # call Django default to set _worker_id and set up parallel DB instances
+    _init_worker(*args, **kwargs)  # call Django default to set _worker_id and set up parallel DB instances
     # _worker_id is now 1, 2, 3, 4, etc.
 
     from django.test.runner import _worker_id

nautobot/core/tests/test_api.py

@@ -992,6 +992,7 @@ class NewUIGetMenuAPIViewTestCase(testing.APITestCase):
                     "Custom Links": "/extras/custom-links/",
                     "Notes": "/extras/notes/",
                 },
+                "Users": {"Saved Views": "/extras/saved-views/"},
             },
         }
 

nautobot/core/tests/test_authentication.py

@@ -4,6 +4,7 @@ from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import Group
 from django.contrib.contenttypes.models import ContentType
+from django.db.models import Q
 from django.test.utils import override_settings
 from django.urls import reverse
 from netaddr import IPNetwork
@@ -573,10 +574,14 @@ class ObjectPermissionAPIViewTestCase(TestCase):
 
         # Check against 1st user's response
         self.assertEqual(response_user1.status_code, 200)
-        self.assertEqual(response_user1.data["count"], 1)
+        self.assertEqual(
+            response_user1.data["count"], ObjectChange.objects.filter(Q(user=self.user) | Q(action="delete")).count()
+        )
         self.assertEqual(response_user1.data["results"][0]["user"]["id"], self.user.pk)
 
         # Check against 2nd user's response
         self.assertEqual(response_user2.status_code, 200)
-        self.assertEqual(response_user2.data["count"], 1)
+        self.assertEqual(
+            response_user2.data["count"], ObjectChange.objects.filter(Q(user=obj_user2) | Q(action="delete")).count()
+        )
         self.assertEqual(response_user2.data["results"][0]["user"]["id"], obj_user2.pk)

nautobot/core/tests/test_filters.py

@@ -142,6 +142,7 @@ class TreeNodeMultipleChoiceFilterTest(TestCase):
                 self.child_location_2ab,
                 self.child_location_same_name_2,
             ],
+            ordered=False,
         )
 
     def test_filter_null(self):
@@ -212,6 +213,7 @@ class TreeNodeMultipleChoiceFilterTest(TestCase):
                 self.child_location_2ab,
                 self.child_location_same_name_2,
             ],
+            ordered=False,
         )
 
     def test_filter_combined_name_exclude(self):
@@ -1304,14 +1306,14 @@ class SearchFilterTest(TestCase, testing.NautobotTestCaseMixin):
             parent=self.parent_location_1,
             name="Test Child Location 1",
             location_type=self.lt,
-            asn=1234,
+            asn=12345,
             status=status,
         )
         self.child_location_2 = dcim_models.Location.objects.create(
             parent=self.parent_location_2,
             name="Test Child Location 2",
             location_type=self.lt,
-            asn=12345,
+            asn=123456,
             status=status,
         )
         self.child_location_3 = dcim_models.Location.objects.create(
@@ -1353,19 +1355,19 @@ class SearchFilterTest(TestCase, testing.NautobotTestCaseMixin):
 
     def test_default_exact(self):
         """Test a default search for an "exact" value."""
-        params = {"q": "1234"}
+        params = {"q": "12345"}
         self.assertQuerysetEqualAndNotEmpty(
-            self.filterset_class(params, self.queryset).qs, self.queryset.filter(asn__exact="1234")
+            self.filterset_class(params, self.queryset).qs, self.queryset.filter(asn__exact=12345)
         )
         asn = (
-            dcim_models.Location.objects.exclude(asn="1234")
+            dcim_models.Location.objects.exclude(asn="12345")
             .exclude(asn__isnull=True)
             .values_list("asn", flat=True)
             .first()
         )
         params = {"q": str(asn)}
         self.assertQuerysetEqualAndNotEmpty(
-            self.filterset_class(params, self.queryset).qs, self.queryset.filter(asn__exact=str(asn))
+            self.filterset_class(params, self.queryset).qs, self.queryset.filter(asn__exact=asn)
         )
 
     def test_default_id(self):
@@ -1389,9 +1391,9 @@ class SearchFilterTest(TestCase, testing.NautobotTestCaseMixin):
 
             q = filters.SearchFilter(filter_predicates={"asn": {"lookup_expr": "exact", "preprocessor": int}})
 
-        params = {"q": "1234"}
+        params = {"q": "12345"}
         self.assertQuerysetEqualAndNotEmpty(
-            MyLocationFilterSet(params, self.queryset).qs, self.queryset.filter(asn__exact="1234")
+            MyLocationFilterSet(params, self.queryset).qs, self.queryset.filter(asn__exact="12345")
         )
         params = {"q": "123"}
         # Both querysets are empty so we dont use assertQuerysetEqualAndNotEmpty here.
@@ -1403,7 +1405,7 @@ class SearchFilterTest(TestCase, testing.NautobotTestCaseMixin):
 
             q = filters.SearchFilter(filter_predicates={"asn": {"lookup_expr": "exact", "preprocessor": dict}})
 
-        params = {"q": "1234"}
+        params = {"q": "12345"}
         # Both querysets are empty so we dont use assertQuerysetEqualAndNotEmpty here.
         self.assertEqual(self.get_filterset_count(params, MyLocationFilterSet2), 0)
 

nautobot/core/tests/test_forms.py

@@ -637,11 +637,14 @@ class DynamicFilterFormTest(TestCase):
                 form._get_lookup_field_choices(),
                 [
                     ("color", "Color"),
+                    ("contacts", "Contacts (name or ID)"),
                     ("content_types", "Content type(s)"),
                     ("created", "Created"),
+                    ("dynamic_groups", "Dynamic groups (name or ID)"),
                     ("id", "Id"),
                     ("last_updated", "Last updated"),
                     ("name", "Name"),
+                    ("teams", "Teams (name or ID)"),
                 ],
             )
             self.assertEqual(
@@ -655,9 +658,11 @@ class DynamicFilterFormTest(TestCase):
                     ("contact_email", "Contact E-mail"),
                     ("contact_name", "Contact name"),
                     ("contact_phone", "Contact phone"),
+                    ("contacts", "Contacts (name or ID)"),
                     ("created", "Created"),
                     ("description", "Description"),
                     ("devices", "Devices (name or ID)"),
+                    ("dynamic_groups", "Dynamic groups (name or ID)"),
                     ("cf_example_app_auto_custom_field", "Example App Automatically Added Custom Field"),
                     ("facility", "Facility"),
                     ("has_vlan_groups", "Has VLAN groups"),
@@ -687,6 +692,7 @@ class DynamicFilterFormTest(TestCase):
                     ("status", "Status (name or ID)"),
                     ("vlans", "Tagged VLANs (VID or ID)"),
                     ("tags", "Tags"),
+                    ("teams", "Teams (name or ID)"),
                     ("tenant_id", 'Tenant (ID) (deprecated, use "tenant" filter instead)'),
                     ("tenant", "Tenant (name or ID)"),
                     ("tenant_group", "Tenant Group (name or ID)"),
@@ -723,11 +729,14 @@ class DynamicFilterFormTest(TestCase):
                 [
                     (None, "---------"),
                     ("color", "Color"),
+                    ("contacts", "Contacts (name or ID)"),
                     ("content_types", "Content type(s)"),
                     ("created", "Created"),
+                    ("dynamic_groups", "Dynamic groups (name or ID)"),
                     ("id", "Id"),
                     ("last_updated", "Last updated"),
                     ("name", "Name"),
+                    ("teams", "Teams (name or ID)"),
                 ],
             )
             self.assertEqual(

nautobot/core/tests/test_graphql.py

@@ -52,6 +52,8 @@ from nautobot.dcim.models import (
     InterfaceRedundancyGroupAssociation,
     Location,
     LocationType,
+    Manufacturer,
+    Module,
     PowerFeed,
     PowerOutlet,
     PowerPanel,
@@ -93,15 +95,13 @@ User = get_user_model()
 
 
 class GraphQLTestCaseBase(TestCase):
-    @classmethod
-    def setUpTestData(cls):
-        # TODO: the below *shouldn't* be needed, but without it, when run with --parallel test flag,
-        # these tests consistently fail with schema construction errors
-        cls.SCHEMA = graphene_settings.SCHEMA  # not a no-op; this causes the schema to be built
+    def setUp(self):
+        self.SCHEMA = graphene_settings.SCHEMA  # not a no-op; this causes the schema to be built when first called
 
 
 class GraphQLTestCase(GraphQLTestCaseBase):
     def setUp(self):
+        super().setUp()
         self.user = create_test_user("graphql_testuser")
         GraphQLQuery.objects.create(name="GQL 1", query="{ query: locations {name} }")
         GraphQLQuery.objects.create(name="GQL 2", query="query ($name: [String!]) { locations(name:$name) {name} }")
@@ -178,7 +178,7 @@ class GraphQLTestCase(GraphQLTestCaseBase):
         for app_label, models in registry["model_features"]["graphql"].items():
             for model_name in models:
                 model = apps.get_model(app_label=app_label, model_name=model_name)
-                self.assertIsNotNone(graphene_django_registry.get_type_for_model(model))
+                self.assertIsNotNone(graphene_django_registry.get_type_for_model(model), model)
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_graphql_url_field(self):
@@ -238,6 +238,7 @@ class GraphQLGenerateSchemaTypeTestCase(GraphQLTestCaseBase):
 
 class GraphQLExtendSchemaType(GraphQLTestCaseBase):
     def setUp(self):
+        super().setUp()
         self.datas = (
             {"field_name": "my_text", "field_type": CustomFieldTypeChoices.TYPE_TEXT},
             {
@@ -329,6 +330,7 @@ class GraphQLExtendSchemaType(GraphQLTestCaseBase):
 
 class GraphQLExtendSchemaRelationship(GraphQLTestCaseBase):
     def setUp(self):
+        super().setUp()
         location_ct = ContentType.objects.get_for_model(Location)
         rack_ct = ContentType.objects.get_for_model(Rack)
         vlan_ct = ContentType.objects.get_for_model(VLAN)
@@ -455,6 +457,7 @@ class GraphQLExtendSchemaRelationship(GraphQLTestCaseBase):
 
 class GraphQLSearchParameters(GraphQLTestCaseBase):
     def setUp(self):
+        super().setUp()
         self.schema = generate_schema_type(app_name="dcim", model=Location)
 
     def test_search_parameters(self):
@@ -476,8 +479,6 @@ class GraphQLAPIPermissionTest(GraphQLTestCaseBase):
     @classmethod
     def setUpTestData(cls):
         """Initialize the Database with some datas and multiple users associated with different permissions."""
-        super().setUpTestData()
-
         cls.groups = (
             Group.objects.create(name="Group 1"),
             Group.objects.create(name="Group 2"),
@@ -705,22 +706,23 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
     @classmethod
     def setUpTestData(cls):
         """Initialize the Database with some datas."""
-        super().setUpTestData()
         cls.user = User.objects.create(username="Super User", is_active=True, is_superuser=True)
 
-        # Remove random IPAddress and Device fixtures for this custom test
+        # Remove random IPAddress, Module and Device fixtures for this custom test
         IPAddress.objects.all().delete()
         Controller.objects.filter(controller_device__isnull=False).delete()
         Device.objects.all().delete()
+        Module.objects.all().delete()
 
         # Initialize fake request that will be required to execute GraphQL query
         cls.request = RequestFactory().request(SERVER_NAME="WebRequestContext")
         cls.request.id = uuid.uuid4()
         cls.request.user = cls.user
 
-        # Populate Data
-        cls.device_type1 = DeviceType.objects.first()
-        cls.device_type2 = DeviceType.objects.last()
+        # Populate Data - create new device types with no component templates
+        manufacturer = Manufacturer.objects.first()
+        cls.device_type1 = DeviceType.objects.create(manufacturer=manufacturer, model="test device_type1")
+        cls.device_type2 = DeviceType.objects.create(manufacturer=manufacturer, model="test device_type2")
         roles = Role.objects.get_for_model(Device)
         cls.device_role1 = roles[0]
         cls.device_role2 = roles[1]
@@ -863,6 +865,7 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
         ]
 
         interface_status = Status.objects.get_for_model(Interface).first()
+        interface_role = Role.objects.get_for_model(Interface).first()
         cls.interface11 = Interface.objects.create(
             name="Int1",
             type=InterfaceTypeChoices.TYPE_VIRTUAL,
@@ -871,12 +874,14 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
             mode=InterfaceModeChoices.MODE_ACCESS,
             untagged_vlan=cls.vlan1,
             status=interface_status,
+            role=interface_role,
         )
         cls.interface12 = Interface.objects.create(
             name="Int2",
             type=InterfaceTypeChoices.TYPE_VIRTUAL,
             device=cls.device1,
             status=interface_status,
+            role=interface_role,
         )
         cls.namespace = Namespace.objects.first()
         cls.intr_group_status = Status.objects.get_for_model(InterfaceRedundancyGroup).first()
@@ -958,6 +963,7 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
             untagged_vlan=cls.vlan2,
             mode=InterfaceModeChoices.MODE_ACCESS,
             status=interface_status,
+            role=interface_role,
         )
         cls.interface22 = Interface.objects.create(
             name="Int2",
@@ -984,7 +990,11 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
         )
 
         cls.interface31 = Interface.objects.create(
-            name="Int1", type=InterfaceTypeChoices.TYPE_VIRTUAL, device=cls.device3, status=interface_status
+            name="Int1",
+            type=InterfaceTypeChoices.TYPE_VIRTUAL,
+            device=cls.device3,
+            status=interface_status,
+            role=interface_role,
         )
         cls.interface31 = Interface.objects.create(
             name="Mgmt1",
@@ -993,6 +1003,7 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
             mgmt_only=True,
             enabled=False,
             status=interface_status,
+            role=interface_role,
         )
 
         cable_statuses = Status.objects.get_for_model(Cable)
@@ -2197,7 +2208,7 @@ query {
         self.assertIsNone(result.errors)
         self.assertIsInstance(result.data, dict, result)
         self.assertIsInstance(result.data["device_types"], list, result)
-        self.assertEqual(result.data["device_types"][0]["model"], self.device_type1.model, result)
+        self.assertEqual(result.data["device_types"][0]["model"], DeviceType.objects.first().model, result)
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_interface_pagination(self):
@@ -2233,7 +2244,7 @@ query {
         self.assertEqual(interface_names, ["Int2", "Int1"])
 
         result_2 = self.execute_query(query_all)
-        self.assertEqual(len(result_2.data.get("interfaces", [])), 6)
+        self.assertEqual(len(result_2.data.get("interfaces", [])), Interface.objects.count())
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_power_feeds_cable_peer(self):

nautobot/core/tests/test_jobs.py

@@ -1,18 +1,25 @@
+from datetime import timedelta
 from pathlib import Path
 
 from django.contrib.contenttypes.models import ContentType
+from django.core.cache import cache
 from django.core.files.base import ContentFile
+from django.utils import timezone
 import yaml
 
+from nautobot.core.jobs.cleanup import CleanupTypes
 from nautobot.core.testing import create_job_result_and_run_job, TransactionTestCase
 from nautobot.dcim.models import Device, DeviceType, Location, LocationType, Manufacturer
 from nautobot.extras.choices import JobResultStatusChoices, LogLevelChoices
+from nautobot.extras.factory import JobResultFactory, ObjectChangeFactory
 from nautobot.extras.models import (
     Contact,
     ContactAssociation,
     ExportTemplate,
     FileProxy,
     JobLogEntry,
+    JobResult,
+    ObjectChange,
     Role,
     Status,
 )
@@ -413,3 +420,118 @@ class ImportObjectsTestCase(TransactionTestCase):
         )
 
         self.assertEqual(associations_job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+
+
+class LogsCleanupTestCase(TransactionTestCase):
+    """
+    Test the LogsCleanup system job.
+    """
+
+    databases = ("default", "job_logs")
+
+    def setUp(self):
+        super().setUp()
+        # Recall that TransactionTestCase truncates the DB after each test case...
+        cache.delete("nautobot.extras.utils.change_logged_models_queryset")
+        if ObjectChange.objects.count() < 2:
+            ObjectChangeFactory.create_batch(40)
+        if JobResult.objects.count() < 2:
+            JobResultFactory.create_batch(20)
+
+    def test_cleanup_without_permission(self):
+        """Job should enforce user permissions on the content-types being deleted."""
+        job_result_count = JobResult.objects.count()
+        job_log_entry_count = JobLogEntry.objects.count()
+        object_change_count = ObjectChange.objects.count()
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.cleanup",
+            "LogsCleanup",
+            username=self.user.username,
+            cleanup_types=[CleanupTypes.JOB_RESULT],
+            max_age=0,
+        )
+        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 delete JobResult records')
+        self.assertEqual(JobResult.objects.count(), job_result_count + 1)
+        self.assertGreater(JobLogEntry.objects.count(), job_log_entry_count)
+        self.assertEqual(ObjectChange.objects.count(), object_change_count)
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.cleanup",
+            "LogsCleanup",
+            username=self.user.username,
+            cleanup_types=[CleanupTypes.OBJECT_CHANGE],
+            max_age=0,
+        )
+        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 delete ObjectChange records'
+        )
+        self.assertEqual(JobResult.objects.count(), job_result_count + 2)
+        self.assertGreater(JobLogEntry.objects.count(), job_log_entry_count)
+        self.assertEqual(ObjectChange.objects.count(), object_change_count)
+
+    def test_cleanup_with_constrained_permission(self):
+        """Job should only allow the user to cleanup records they have permission to delete."""
+        job_result_1 = JobResult.objects.last()
+        job_result_2 = JobResult.objects.first()
+        self.assertNotEqual(job_result_1.pk, job_result_2.pk)
+        object_change_1 = ObjectChange.objects.first()
+        object_change_2 = ObjectChange.objects.last()
+        self.assertNotEqual(object_change_1.pk, object_change_2.pk)
+        obj_perm = ObjectPermission(
+            name="Test permission",
+            constraints={"pk__in": [str(job_result_1.pk), str(object_change_1.pk)]},
+            actions=["delete"],
+        )
+        obj_perm.save()
+        obj_perm.users.add(self.user)
+        obj_perm.object_types.add(ContentType.objects.get_for_model(JobResult))
+        obj_perm.object_types.add(ContentType.objects.get_for_model(ObjectChange))
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.cleanup",
+            "LogsCleanup",
+            username=self.user.username,
+            cleanup_types=[CleanupTypes.JOB_RESULT, CleanupTypes.OBJECT_CHANGE],
+            max_age=0,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertEqual(job_result.result["extras.JobResult"], 1)
+        self.assertEqual(job_result.result["extras.ObjectChange"], 1)
+        with self.assertRaises(JobResult.DoesNotExist):
+            JobResult.objects.get(pk=job_result_1.pk)
+        JobResult.objects.get(pk=job_result_2.pk)
+        with self.assertRaises(ObjectChange.DoesNotExist):
+            ObjectChange.objects.get(pk=object_change_1.pk)
+        ObjectChange.objects.get(pk=object_change_2.pk)
+
+    def test_cleanup_job_results(self):
+        """With unconstrained permissions, all JobResults before the cutoff should be deleted."""
+        cutoff = timezone.now() - timedelta(days=60)
+        create_job_result_and_run_job(
+            "nautobot.core.jobs.cleanup",
+            "LogsCleanup",
+            cleanup_types=[CleanupTypes.JOB_RESULT],
+            max_age=60,
+        )
+        self.assertFalse(JobResult.objects.filter(date_done__lt=cutoff).exists())
+        self.assertTrue(JobResult.objects.filter(date_done__gte=cutoff).exists())
+        self.assertTrue(ObjectChange.objects.filter(time__lt=cutoff).exists())
+        self.assertTrue(ObjectChange.objects.filter(time__gte=cutoff).exists())
+
+    def test_cleanup_object_changes(self):
+        """With unconstrained permissions, all ObjectChanges before the cutoff should be deleted."""
+        cutoff = timezone.now() - timedelta(days=60)
+        create_job_result_and_run_job(
+            "nautobot.core.jobs.cleanup",
+            "LogsCleanup",
+            cleanup_types=[CleanupTypes.OBJECT_CHANGE],
+            max_age=60,
+        )
+        self.assertTrue(JobResult.objects.filter(date_done__lt=cutoff).exists())
+        self.assertTrue(JobResult.objects.filter(date_done__gte=cutoff).exists())
+        self.assertFalse(ObjectChange.objects.filter(time__lt=cutoff).exists())
+        self.assertTrue(ObjectChange.objects.filter(time__gte=cutoff).exists())