nautobot 2.4.16__py3-none-any.whl → 2.4.18__py3-none-any.whl

nautobot/extras/tests/test_models.py

@@ -153,6 +153,10 @@ class ComputedFieldTest(ModelTestCases.BaseModelTestCase):
             secret_type=SecretsGroupSecretTypeChoices.TYPE_SECRET,
         )
 
+        # Template strings for validation testing (cannot be saved due to syntax errors)
+        self.invalid_template_unclosed_bracket = "{{ obj.name }"
+        self.invalid_template_unknown_tag = "{% unknowntag %}{{ obj.name }}{% endunknowntag %}"
+
     def test_render_method(self):
         rendered_value = self.good_computed_field.render(context={"obj": self.location1})
         self.assertEqual(rendered_value, f"{self.location1.name} is awesome!")
@@ -214,6 +218,218 @@ class ComputedFieldTest(ModelTestCases.BaseModelTestCase):
             str(error.exception),
         )
 
+    def test_template_validation_invalid_syntax(self):
+        """
+        Test that ComputedField with invalid Jinja2 template syntax raises ValidationError.
+        """
+        # Invalid template with syntax error - unclosed bracket
+        invalid_computed_field = ComputedField(
+            label="Invalid Template Test",
+            key="invalid_template_test",
+            template=self.invalid_template_unclosed_bracket,
+            content_type=ContentType.objects.get_for_model(Device),
+        )
+
+        with self.assertRaises(ValidationError) as context:
+            invalid_computed_field.full_clean()
+
+        # Check that the error message contains template-specific information
+        error_dict = context.exception.error_dict
+        self.assertIn("template", error_dict)
+        self.assertIn("Template syntax error", str(error_dict["template"][0]))
+        self.assertIn("line", str(error_dict["template"][0]))
+
+    def test_template_validation_invalid_tag(self):
+        """
+        Test that ComputedField with invalid Jinja2 tag raises ValidationError.
+        """
+        # Invalid template with unknown tag
+        invalid_computed_field = ComputedField(
+            label="Invalid Tag Test",
+            key="invalid_tag_test",
+            template=self.invalid_template_unknown_tag,
+            content_type=ContentType.objects.get_for_model(Device),
+        )
+
+        with self.assertRaises(ValidationError) as context:
+            invalid_computed_field.full_clean()
+
+        # Check that the error message contains template-specific information
+        error_dict = context.exception.error_dict
+        self.assertIn("template", error_dict)
+        self.assertIn("Template syntax error", str(error_dict["template"][0]))
+
+    def test_bulk_create_valid_templates(self):
+        """Test that bulk_create works with valid templates."""
+        valid_fields = [
+            ComputedField(
+                label="Bulk Test 1",
+                key="bulk_test_1",
+                template="{{ obj.name }} - Test 1",
+                content_type=ContentType.objects.get_for_model(Device),
+            ),
+            ComputedField(
+                label="Bulk Test 2",
+                key="bulk_test_2",
+                template="{{ obj.id }} - Test 2",
+                content_type=ContentType.objects.get_for_model(Device),
+            ),
+        ]
+
+        # Should not raise ValidationError
+        created_fields = ComputedField.objects.bulk_create(valid_fields)
+        self.assertEqual(len(created_fields), 2)
+
+    def test_bulk_create_invalid_templates(self):
+        """Test that bulk_create fails with invalid templates and reports all errors."""
+        invalid_fields = [
+            ComputedField(
+                label="Invalid Test 1",
+                key="invalid_test_1",
+                template=self.invalid_template_unclosed_bracket,
+                content_type=ContentType.objects.get_for_model(Device),
+            ),
+            ComputedField(
+                label="Invalid Test 2",
+                key="invalid_test_2",
+                template=self.invalid_template_unknown_tag,
+                content_type=ContentType.objects.get_for_model(Device),
+            ),
+        ]
+
+        with self.assertRaises(ValidationError) as context:
+            ComputedField.objects.bulk_create(invalid_fields)
+
+        # Check that both errors are reported
+        error_message = str(context.exception)
+        self.assertIn("Template validation failed", error_message)
+        self.assertIn("Invalid Test 1", error_message)
+        self.assertIn("Invalid Test 2", error_message)
+
+    def test_bulk_update_template_field(self):
+        """Test that bulk_update validates templates when template field is updated."""
+        # Create valid objects first
+        valid_fields = [
+            ComputedField(
+                label="Update Test 1",
+                key="update_test_1",
+                template="{{ obj.name }}",
+                content_type=ContentType.objects.get_for_model(Device),
+            ),
+            ComputedField(
+                label="Update Test 2",
+                key="update_test_2",
+                template="{{ obj.id }}",
+                content_type=ContentType.objects.get_for_model(Device),
+            ),
+        ]
+        created_fields = ComputedField.objects.bulk_create(valid_fields)
+
+        # Update with invalid templates
+        for field in created_fields:
+            field.template = self.invalid_template_unclosed_bracket
+
+        with self.assertRaises(ValidationError) as context:
+            ComputedField.objects.bulk_update(created_fields, ["template"])
+
+        # Check that validation error occurred
+        error_message = str(context.exception)
+        self.assertIn("Template validation failed", error_message)
+        self.assertIn("Update Test 1", error_message)
+        self.assertIn("Update Test 2", error_message)
+
+    def test_bulk_update_non_template_field(self):
+        """Test that bulk_update skips template validation when template field is not updated."""
+        # Create a field with invalid template (bypassing validation for this test)
+        field = ComputedField(
+            label="Non-template Update Test",
+            key="non_template_update_test",
+            template="{{ obj.name }}",  # Start with valid template
+            content_type=ContentType.objects.get_for_model(Device),
+        )
+        field.save()
+
+        # Manually set invalid template (simulating existing invalid data)
+        ComputedField.objects.filter(pk=field.pk).update(template=self.invalid_template_unclosed_bracket)
+        field.refresh_from_db()
+
+        # Update only the label field - should not trigger template validation
+        field.label = "Updated Label"
+        try:
+            ComputedField.objects.bulk_update([field], ["label"])
+        except ValidationError:
+            self.fail("bulk_update should not validate templates when template field is not being updated")
+
+    def test_bulk_create_mixed_valid_invalid(self):
+        """Test that bulk_create fails when mixing valid and invalid templates."""
+        mixed_fields = [
+            ComputedField(
+                label="Valid Mixed Test",
+                key="valid_mixed_test",
+                template="{{ obj.name }} - Valid",
+                content_type=ContentType.objects.get_for_model(Device),
+            ),
+            ComputedField(
+                label="Invalid Mixed Test",
+                key="invalid_mixed_test",
+                template=self.invalid_template_unclosed_bracket,
+                content_type=ContentType.objects.get_for_model(Device),
+            ),
+        ]
+
+        with self.assertRaises(ValidationError) as context:
+            ComputedField.objects.bulk_create(mixed_fields)
+
+        # Check that the invalid object is reported but valid one is not
+        error_message = str(context.exception)
+        self.assertIn("Template validation failed", error_message)
+        self.assertIn("Invalid Mixed Test", error_message)
+        # Valid object should not appear in error message
+        self.assertNotIn("Valid Mixed Test", error_message)
+
+        # Verify no objects were created (all-or-nothing behavior)
+        self.assertFalse(ComputedField.objects.filter(key="valid_mixed_test").exists())
+        self.assertFalse(ComputedField.objects.filter(key="invalid_mixed_test").exists())
+
+    def test_bulk_update_mixed_valid_invalid(self):
+        """Test that bulk_update fails when mixing valid and invalid template updates."""
+        # Create valid objects first
+        valid_fields = [
+            ComputedField(
+                label="Valid Update Mixed",
+                key="valid_update_mixed",
+                template="{{ obj.name }}",
+                content_type=ContentType.objects.get_for_model(Device),
+            ),
+            ComputedField(
+                label="Invalid Update Mixed",
+                key="invalid_update_mixed",
+                template="{{ obj.id }}",
+                content_type=ContentType.objects.get_for_model(Device),
+            ),
+        ]
+        created_fields = ComputedField.objects.bulk_create(valid_fields)
+
+        # Update: one with valid template, one with invalid
+        created_fields[0].template = "{{ obj.name }} - Updated Valid"  # Valid
+        created_fields[1].template = self.invalid_template_unclosed_bracket  # Invalid
+
+        with self.assertRaises(ValidationError) as context:
+            ComputedField.objects.bulk_update(created_fields, ["template"])
+
+        # Check that only the invalid object is reported
+        error_message = str(context.exception)
+        self.assertIn("Template validation failed", error_message)
+        self.assertIn("Invalid Update Mixed", error_message)
+        # Valid object should not appear in error message
+        self.assertNotIn("Valid Update Mixed", error_message)
+
+        # Verify templates were not updated (all-or-nothing behavior)
+        created_fields[0].refresh_from_db()
+        created_fields[1].refresh_from_db()
+        self.assertEqual(created_fields[0].template, "{{ obj.name }}")  # Original template
+        self.assertEqual(created_fields[1].template, "{{ obj.id }}")  # Original template
+
 
 class ConfigContextTest(ModelTestCases.BaseModelTestCase):
     """

nautobot/extras/tests/test_views.py

@@ -205,7 +205,7 @@ class ComputedFieldRenderingTestCase(TestCase):
     def test_view_object_with_computed_field_fallback_value(self):
         """Ensure that the fallback_value is rendered if the template fails to render."""
         # Make the template invalid to demonstrate the fallback value
-        self.computedfield.template = "FOO {{ obj."
+        self.computedfield.template = "FOO {{ obj | invalid_filter }}"
         self.computedfield.validated_save()
         response = self.client.get(self.location_type.get_absolute_url(), follow=True)
         self.assertEqual(response.status_code, 200)
@@ -224,7 +224,7 @@ class ComputedFieldRenderingTestCase(TestCase):
 
     def test_view_object_with_computed_field_unsafe_fallback_value(self):
         """Ensure that computed field fallback values can't be used as an XSS vector."""
-        self.computedfield.template = "FOO {{ obj."
+        self.computedfield.template = "FOO {{ obj | invalid_filter }}"
         self.computedfield.fallback_value = '<script>alert("Hello world!"</script>'
         self.computedfield.validated_save()
         response = self.client.get(self.location_type.get_absolute_url(), follow=True)
@@ -979,6 +979,7 @@ class DynamicGroupTestCase(
     ViewTestCases.GetObjectChangelogViewTestCase,
     ViewTestCases.ListObjectsViewTestCase,
     ViewTestCases.BulkDeleteObjectsViewTestCase,
+    ViewTestCases.BulkEditObjectsViewTestCase,
     # NOTE: This isn't using `ViewTestCases.PrimaryObjectViewTestCase` because bulk-import/edit
     # views for DynamicGroup do not make sense at this time, primarily because `content_type` is
     # immutable after create.
@@ -1009,6 +1010,10 @@ class DynamicGroupTestCase(
             "dynamic_group_memberships-MIN_NUM_FORMS": "0",
             "dynamic_group_memberships-MAX_NUM_FORMS": "1000",
         }
+        cls.bulk_edit_data = {
+            "description": "This is a very detailed new description",
+            "tenant": Tenant.objects.last().pk,
+        }
 
     def _get_queryset(self):
         return super()._get_queryset().filter(group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_FILTER)  # TODO

nautobot/extras/urls.py

@@ -3,8 +3,6 @@ from django.urls import path
 from nautobot.core.views.routers import NautobotUIViewSetRouter
 from nautobot.extras import views
 from nautobot.extras.models import (
-    DynamicGroup,
-    GitRepository,
     Job,
     Relationship,
 )
@@ -19,8 +17,10 @@ router.register("contacts", views.ContactUIViewSet)
 router.register("contact-associations", views.ContactAssociationUIViewSet)
 router.register("custom-fields", views.CustomFieldUIViewSet)
 router.register("custom-links", views.CustomLinkUIViewSet)
+router.register("dynamic-groups", views.DynamicGroupUIViewSet)
 router.register("export-templates", views.ExportTemplateUIViewSet)
 router.register("external-integrations", views.ExternalIntegrationUIViewSet)
+router.register("git-repositories", views.GitRepositoryUIViewSet)
 router.register("graphql-queries", views.GraphQLQueryUIViewSet)
 router.register("job-buttons", views.JobButtonUIViewSet)
 router.register("job-hooks", views.JobHookUIViewSet)
@@ -59,98 +59,6 @@ urlpatterns = [
         views.ObjectAssignContactOrTeamView.as_view(),
         name="object_contact_team_assign",
     ),
-    # Dynamic Groups
-    path("dynamic-groups/", views.DynamicGroupListView.as_view(), name="dynamicgroup_list"),
-    path("dynamic-groups/add/", views.DynamicGroupEditView.as_view(), name="dynamicgroup_add"),
-    path("dynamic-groups/assign-members/", views.DynamicGroupBulkAssignView.as_view(), name="dynamicgroup_bulk_assign"),
-    path(
-        "dynamic-groups/delete/",
-        views.DynamicGroupBulkDeleteView.as_view(),
-        name="dynamicgroup_bulk_delete",
-    ),
-    path("dynamic-groups/<uuid:pk>/", views.DynamicGroupView.as_view(), name="dynamicgroup"),
-    path("dynamic-groups/<uuid:pk>/edit/", views.DynamicGroupEditView.as_view(), name="dynamicgroup_edit"),
-    path("dynamic-groups/<uuid:pk>/delete/", views.DynamicGroupDeleteView.as_view(), name="dynamicgroup_delete"),
-    path(
-        "dynamic-groups/<uuid:pk>/changelog/",
-        views.ObjectChangeLogView.as_view(),
-        name="dynamicgroup_changelog",
-        kwargs={"model": DynamicGroup},
-    ),
-    path(
-        "dynamic-groups/<uuid:pk>/notes/",
-        views.ObjectNotesView.as_view(),
-        name="dynamicgroup_notes",
-        kwargs={"model": DynamicGroup},
-    ),
-    # Git repositories
-    path(
-        "git-repositories/",
-        views.GitRepositoryListView.as_view(),
-        name="gitrepository_list",
-    ),
-    path(
-        "git-repositories/add/",
-        views.GitRepositoryEditView.as_view(),
-        name="gitrepository_add",
-    ),
-    path(
-        "git-repositories/delete/",
-        views.GitRepositoryBulkDeleteView.as_view(),
-        name="gitrepository_bulk_delete",
-    ),
-    path(
-        "git-repositories/edit/",
-        views.GitRepositoryBulkEditView.as_view(),
-        name="gitrepository_bulk_edit",
-    ),
-    path(
-        "git-repositories/import/",
-        views.GitRepositoryBulkImportView.as_view(),  # 3.0 TODO: remove, unused
-        name="gitrepository_import",
-    ),
-    path(
-        "git-repositories/<uuid:pk>/",
-        views.GitRepositoryView.as_view(),
-        name="gitrepository",
-    ),
-    path(
-        "git-repositories/<uuid:pk>/edit/",
-        views.GitRepositoryEditView.as_view(),
-        name="gitrepository_edit",
-    ),
-    path(
-        "git-repositories/<uuid:pk>/delete/",
-        views.GitRepositoryDeleteView.as_view(),
-        name="gitrepository_delete",
-    ),
-    path(
-        "git-repositories/<uuid:pk>/changelog/",
-        views.ObjectChangeLogView.as_view(),
-        name="gitrepository_changelog",
-        kwargs={"model": GitRepository},
-    ),
-    path(
-        "git-repositories/<uuid:pk>/notes/",
-        views.ObjectNotesView.as_view(),
-        name="gitrepository_notes",
-        kwargs={"model": GitRepository},
-    ),
-    path(
-        "git-repositories/<uuid:pk>/result/",
-        views.GitRepositoryResultView.as_view(),
-        name="gitrepository_result",
-    ),
-    path(
-        "git-repositories/<uuid:pk>/sync/",
-        views.GitRepositorySyncView.as_view(),
-        name="gitrepository_sync",
-    ),
-    path(
-        "git-repositories/<uuid:pk>/dry-run/",
-        views.GitRepositoryDryRunView.as_view(),
-        name="gitrepository_dryrun",
-    ),
     # Image attachments
     path(
         "image-attachments/<uuid:pk>/edit/",