nautobot 2.4.13__py3-none-any.whl → 2.4.15__py3-none-any.whl

nautobot/extras/tests/test_customfields.py

@@ -4,7 +4,7 @@ import logging
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
-from django.db.models import ProtectedError
+from django.db.models import ProtectedError, QuerySet
 from django.forms import ChoiceField, IntegerField, NumberInput
 from django.urls import reverse
 from rest_framework import status
@@ -400,28 +400,46 @@ class CustomFieldTest(ModelTestCases.BaseModelTestCase, TestCase):
 class CustomFieldManagerTest(TestCase):
     def setUp(self):
         self.content_type = ContentType.objects.get_for_model(Location)
-        custom_field = CustomField(type=CustomFieldTypeChoices.TYPE_TEXT, label="Text Field", default="foo")
+        custom_field = CustomField(
+            type=CustomFieldTypeChoices.TYPE_TEXT,
+            label="Text Field",
+            default="foo",
+            filter_logic=CustomFieldFilterLogicChoices.FILTER_DISABLED,
+        )
         custom_field.save()
         custom_field.content_types.set([self.content_type])
 
     def test_get_for_model(self):
         self.assertEqual(CustomField.objects.get_for_model(Location).count(), 2)
         self.assertEqual(CustomField.objects.get_for_model(VirtualMachine).count(), 0)
+        self.assertEqual(len(CustomField.objects.get_for_model(Location, get_queryset=False)), 2)
+        self.assertEqual(len(CustomField.objects.get_for_model(VirtualMachine, get_queryset=False)), 0)
 
     def test_get_for_model_caching_and_cache_invalidation(self):
         """Test that the cache is used and is properly invalidated when CustomFields are created or deleted."""
         # Assert that the cache is used when calling get_for_model a second time
         CustomField.objects.get_for_model(Location)
         with self.assertNumQueries(0):
-            CustomField.objects.get_for_model(Location)
+            qs = CustomField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            listing = CustomField.objects.get_for_model(Location, get_queryset=False)
+        self.assertIsInstance(qs, QuerySet)
+        self.assertIsInstance(listing, list)
+        self.assertQuerysetEqualAndNotEmpty(qs, listing)
 
         # Assert that different values of exclude_filter_disabled are cached separately
         with self.assertNumQueries(1):
             CustomField.objects.get_for_model(Location, exclude_filter_disabled=True)
         with self.assertNumQueries(0):
-            CustomField.objects.get_for_model(Location, exclude_filter_disabled=True)
+            qs = CustomField.objects.get_for_model(Location, exclude_filter_disabled=True)
+        with self.assertNumQueries(0):
+            listing = CustomField.objects.get_for_model(Location, exclude_filter_disabled=True, get_queryset=False)
         with self.assertNumQueries(0):
             CustomField.objects.get_for_model(Location)
+        self.assertIsInstance(qs, QuerySet)
+        self.assertIsInstance(listing, list)
+        self.assertEqual(1, len(listing))
+        self.assertQuerysetEqualAndNotEmpty(qs, listing)
 
         # Assert that different models are cached separately
         with self.assertNumQueries(1):
@@ -444,21 +462,111 @@ class CustomFieldManagerTest(TestCase):
         with self.assertNumQueries(1):
             CustomField.objects.get_for_model(Location)
         with self.assertNumQueries(0):
-            CustomField.objects.get_for_model(Location)
+            qs = CustomField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            listing = CustomField.objects.get_for_model(Location, get_queryset=False)
+        self.assertIsInstance(qs, QuerySet)
+        self.assertIsInstance(listing, list)
+        self.assertEqual(3, len(listing))
+        self.assertQuerysetEqualAndNotEmpty(qs, listing)
 
         # Assert that the cache is invalidated when removing a CustomField.content_types m2m relationship
         custom_field.content_types.set([])
         with self.assertNumQueries(1):
             CustomField.objects.get_for_model(Location)
         with self.assertNumQueries(0):
-            CustomField.objects.get_for_model(Location)
+            qs = CustomField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            listing = CustomField.objects.get_for_model(Location, get_queryset=False)
+        self.assertIsInstance(qs, QuerySet)
+        self.assertIsInstance(listing, list)
+        self.assertEqual(2, len(listing))
+        self.assertQuerysetEqualAndNotEmpty(qs, listing)
 
         # Assert that the cache is invalidated on object delete
         custom_field.delete()
         with self.assertNumQueries(1):
             CustomField.objects.get_for_model(Location)
         with self.assertNumQueries(0):
-            CustomField.objects.get_for_model(Location)
+            qs = CustomField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            listing = CustomField.objects.get_for_model(Location, get_queryset=False)
+        self.assertIsInstance(qs, QuerySet)
+        self.assertIsInstance(listing, list)
+        self.assertEqual(2, len(listing))
+        self.assertQuerysetEqualAndNotEmpty(qs, listing)
+
+
+class ComputedFieldManagerTestCase(TestCase):
+    def setUp(self):
+        self.content_type = ContentType.objects.get_for_model(Location)
+        ComputedField.objects.create(
+            content_type=ContentType.objects.get_for_model(Location),
+            key="computed_field_one",
+            label="Computed Field One",
+            template="{{ obj.name }} is the name of this location.",
+            fallback_value="An error occurred while rendering this template.",
+            weight=100,
+        )
+
+    def test_get_for_model(self):
+        self.assertEqual(ComputedField.objects.get_for_model(Location).count(), 1)
+        self.assertEqual(ComputedField.objects.get_for_model(VirtualMachine).count(), 0)
+        self.assertEqual(len(ComputedField.objects.get_for_model(Location, get_queryset=False)), 1)
+        self.assertEqual(len(ComputedField.objects.get_for_model(VirtualMachine, get_queryset=False)), 0)
+
+    def test_get_for_model_caching_and_cache_invalidation(self):
+        # Assert that the cache is used when calling get_for_model a second time
+        ComputedField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            qs = ComputedField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            listing = ComputedField.objects.get_for_model(Location, get_queryset=False)
+        self.assertIsInstance(qs, QuerySet)
+        self.assertIsInstance(listing, list)
+        self.assertEqual(1, len(listing))
+        self.assertQuerysetEqualAndNotEmpty(qs, listing)
+
+        # Assert that different models are cached separately
+        with self.assertNumQueries(1):
+            ComputedField.objects.get_for_model(VirtualMachine)
+        with self.assertNumQueries(0):
+            ComputedField.objects.get_for_model(VirtualMachine)
+        with self.assertNumQueries(0):
+            ComputedField.objects.get_for_model(Location)
+
+        # Assert that the cache is invalidated on object save
+        computed_field = ComputedField.objects.create(
+            content_type=ContentType.objects.get_for_model(Location),
+            key="computed_field_two",
+            label="Computed Field Two",
+            template="{{ obj.name }} is still jthe name of this location.",
+            fallback_value="An error occurred while rendering this template.",
+            weight=200,
+        )
+        with self.assertNumQueries(1):
+            ComputedField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            qs = ComputedField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            listing = ComputedField.objects.get_for_model(Location, get_queryset=False)
+        self.assertIsInstance(qs, QuerySet)
+        self.assertIsInstance(listing, list)
+        self.assertEqual(2, len(listing))
+        self.assertQuerysetEqualAndNotEmpty(qs, listing)
+
+        # Assert that the cache is invalided on object delete
+        computed_field.delete()
+        with self.assertNumQueries(1):
+            ComputedField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            qs = ComputedField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            listing = ComputedField.objects.get_for_model(Location, get_queryset=False)
+        self.assertIsInstance(qs, QuerySet)
+        self.assertIsInstance(listing, list)
+        self.assertEqual(1, len(listing))
+        self.assertQuerysetEqualAndNotEmpty(qs, listing)
 
 
 class CustomFieldDataAPITest(APITestCase):

nautobot/extras/tests/test_filters.py

@@ -171,6 +171,8 @@ class ComputedFieldTestCase(FilterTestCases.FilterTestCase):
     def test_content_type(self):
         params = {"content_type": "dcim.location"}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
+        params = {"content_type__n": "dcim.location"}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
 
 
 class ConfigContextTestCase(FilterTestCases.FilterTestCase):
@@ -650,6 +652,8 @@ class ExportTemplateTestCase(FilterTestCases.FilterTestCase):
     def test_content_type(self):
         params = {"content_type": ContentType.objects.get(model="location").pk}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"content_type__n": ContentType.objects.get(model="location").pk}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
 
 class FileProxyTestCase(FilterTestCases.FilterTestCase):
@@ -865,6 +869,8 @@ class ImageAttachmentTestCase(FilterTestCases.FilterTestCase):
     def test_content_type(self):
         params = {"content_type": "dcim.location"}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+        params = {"content_type__n": "dcim.location"}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_content_type_id_and_object_id(self):
         params = {
@@ -981,6 +987,7 @@ class JobResultFilterSetTestCase(FilterTestCases.FilterTestCase):
     filterset = JobResultFilterSet
     generic_filter_tests = (
         ("date_created",),
+        ("date_started",),
         ("date_done",),
         ("job_model", "job_model__id"),
         ("job_model", "job_model__name"),
@@ -1091,6 +1098,8 @@ class JobHookFilterSetTestCase(FilterTestCases.FilterTestCase):
     def test_content_types(self):
         params = {"content_types": ["dcim.devicetype"]}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+        params = {"content_types__n": ["dcim.devicetype"]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
 
     def test_enabled(self):
         params = {"enabled": True}

nautobot/extras/tests/test_forms.py

@@ -1101,9 +1101,9 @@ class DeprecatedAliasesTestCase(TestCase):
 
     def test_deprecated_form_mixin_classes(self):
         # Importing these mixin classes doesn't directly warn, but subclassing them does.
-        from nautobot.extras.forms import (
+        from nautobot.extras.forms import CustomFieldBulkCreateForm
+        from nautobot.extras.forms.mixins import (
             AddRemoveTagsForm,
-            CustomFieldBulkCreateForm,
             CustomFieldBulkEditForm,
             CustomFieldModelForm,
             RelationshipModelForm,

nautobot/extras/tests/test_plugins.py

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

nautobot/extras/tests/test_relationships.py

@@ -482,10 +482,12 @@ class RelationshipTest(RelationshipBaseTest, ModelTestCases.BaseModelTestCase):
                 # Assert that the cache is used when calling method a second time
                 with self.assertNumQueries(0):
                     manager_method(Location)
+                with self.assertNumQueries(0):
+                    manager_method(Location, get_queryset=False)
 
                 # Assert that different models are cached separately
                 with self.assertNumQueries(expected_queries):
-                    manager_method(Rack)
+                    manager_method(Rack, get_queryset=False)
                 with self.assertNumQueries(0):
                     manager_method(Rack)
                 with self.assertNumQueries(0):
@@ -507,6 +509,8 @@ class RelationshipTest(RelationshipBaseTest, ModelTestCases.BaseModelTestCase):
                         manager_method(Location)
                     with self.assertNumQueries(0):
                         manager_method(Location)
+                    with self.assertNumQueries(0):
+                        manager_method(Location, get_queryset=False)
                 finally:
                     # Assert that the cache is invalidated on object delete
                     relationship.delete()
@@ -514,6 +518,8 @@ class RelationshipTest(RelationshipBaseTest, ModelTestCases.BaseModelTestCase):
                     manager_method(Location)
                 with self.assertNumQueries(0):
                     manager_method(Location)
+                with self.assertNumQueries(0):
+                    manager_method(Location, get_queryset=False)
 
     def test_required_related_object_errors(self):
         """
@@ -1664,7 +1670,7 @@ class RequiredRelationshipTestMixin:
                     response = self.send_data(
                         from_model,
                         {
-                            "name": f'{params["create_data"]["name"]} edited',
+                            "name": f"{params['create_data']['name']} edited",
                             "relationships": {},
                         },
                         interact_with,
@@ -1682,13 +1688,13 @@ class RequiredRelationshipTestMixin:
                     # Object is updated with the required relationship data (succeeds)
                     response = self.send_data(
                         from_model,
-                        {"name": f'{params["create_data"]["name"]} edited', **related_objects_data},
+                        {"name": f"{params['create_data']['name']} edited", **related_objects_data},
                         interact_with,
                         action="edit",
                         url_kwargs={"pk": newly_created_object.pk},
                     )
                     self.assertHttpStatus(response, 200)
-                    self.assertEqual(f'{params["create_data"]["name"]} edited', response.json()["name"])
+                    self.assertEqual(f"{params['create_data']['name']} edited", response.json()["name"])
 
                     """
                     - Object is created with the required relationship data (succeeds)
@@ -1698,7 +1704,7 @@ class RequiredRelationshipTestMixin:
                     """
 
                     # Delete the object that was previously created, so we can test with the same data again
-                    from_model.objects.get(name=f'{params["create_data"]["name"]} edited').delete()
+                    from_model.objects.get(name=f"{params['create_data']['name']} edited").delete()
                     self.assertEqual(from_model.objects.count(), existing_count)
 
                     # Object is created with the required relationship data (succeeds)
@@ -1712,19 +1718,19 @@ class RequiredRelationshipTestMixin:
                     newly_created_object = from_model.objects.get(name=params["create_data"]["name"])
                     response = self.send_data(
                         from_model,
-                        {"name": f'{params["create_data"]["name"]} changed'},
+                        {"name": f"{params['create_data']['name']} changed"},
                         interact_with,
                         action="edit",
                         url_kwargs={"pk": newly_created_object.pk},
                     )
                     self.assertHttpStatus(response, 200)
-                    self.assertEqual(f'{params["create_data"]["name"]} changed', response.json()["name"])
+                    self.assertEqual(f"{params['create_data']['name']} changed", response.json()["name"])
 
                     # Object is updated to remove the relationship data (fails)
                     response = self.send_data(
                         from_model,
                         {
-                            "name": f'{params["create_data"]["name"]} changed again',
+                            "name": f"{params['create_data']['name']} changed again",
                             "relationships": {},
                         },
                         interact_with,