karrio-server-documents 2025.5.2__py3-none-any.whl

karrio/server/documents/tests/test_templates.py

@@ -0,0 +1,318 @@
+import json
+from unittest.mock import ANY
+from django.urls import reverse
+from rest_framework import status
+from karrio.server.core.tests import APITestCase
+from karrio.server.graph.tests.base import GraphTestCase
+from karrio.server.documents.models import DocumentTemplate
+
+
+class TestDocumentTemplatesREST(APITestCase):
+    def test_create_document_template(self):
+        url = reverse("karrio.server.documents:document-template-list")
+        data = DOCUMENT_TEMPLATE_DATA
+
+        response = self.client.post(url, data)
+        response_data = json.loads(response.content)
+
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+
+        # Check individual fields instead of strict dictionary comparison
+        self.assertEqual(response_data["name"], "Test Invoice Template")
+        self.assertEqual(response_data["slug"], "test_invoice")
+        self.assertEqual(response_data["description"], "A test invoice template")
+        self.assertEqual(response_data["object_type"], "document-template")
+        self.assertEqual(response_data["related_object"], "shipment")
+        self.assertEqual(response_data["active"], True)
+        self.assertEqual(response_data["metadata"], {"doc_type": "invoice", "version": "1.0"})
+        self.assertEqual(response_data["options"], {"page_size": "A4", "orientation": "portrait"})
+
+        # Check that ID field exists
+        self.assertIn("id", response_data)
+
+    def test_list_document_templates(self):
+        # Create a template first
+        DocumentTemplate.objects.create(
+            **{
+                "name": "Test Template",
+                "slug": "test_template",
+                "template": SAMPLE_HTML_TEMPLATE,
+                "description": "A test template",
+                "related_object": "shipment",
+                "created_by": self.user,
+            }
+        )
+
+        url = reverse("karrio.server.documents:document-template-list")
+        response = self.client.get(url)
+        response_data = json.loads(response.content)
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertIn("results", response_data)
+        self.assertEqual(len(response_data["results"]), 1)
+        self.assertEqual(response_data["results"][0]["name"], "Test Template")
+
+
+class TestDocumentTemplateDetailsREST(APITestCase):
+    def setUp(self) -> None:
+        super().setUp()
+        self.template: DocumentTemplate = DocumentTemplate.objects.create(
+            **{
+                "name": "Test Template",
+                "slug": "test_template",
+                "template": SAMPLE_HTML_TEMPLATE,
+                "description": "A test template",
+                "related_object": "shipment",
+                "active": True,
+                "metadata": {"doc_type": "invoice"},
+                "options": {"page_size": "A4"},
+                "created_by": self.user,
+            }
+        )
+
+    def test_retrieve_document_template(self):
+        url = reverse(
+            "karrio.server.documents:document-template-details",
+            kwargs=dict(pk=self.template.pk),
+        )
+
+        response = self.client.get(url)
+        response_data = json.loads(response.content)
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        # Check individual fields instead of strict dictionary comparison
+        self.assertEqual(response_data["name"], "Test Template")
+        self.assertEqual(response_data["slug"], "test_template")
+        self.assertEqual(response_data["description"], "A test template")
+        self.assertEqual(response_data["object_type"], "document-template")
+        self.assertEqual(response_data["related_object"], "shipment")
+        self.assertEqual(response_data["active"], True)
+        self.assertEqual(response_data["metadata"], {"doc_type": "invoice"})
+        self.assertEqual(response_data["options"], {"page_size": "A4"})
+        self.assertEqual(response_data["template"], SAMPLE_HTML_TEMPLATE)
+
+        # Check that ID field exists
+        self.assertIn("id", response_data)
+
+    def test_update_document_template(self):
+        url = reverse(
+            "karrio.server.documents:document-template-details",
+            kwargs=dict(pk=self.template.pk),
+        )
+        data = DOCUMENT_TEMPLATE_UPDATE_DATA
+
+        response = self.client.patch(url, data)
+        response_data = json.loads(response.content)
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertDictEqual(response_data, DOCUMENT_TEMPLATE_UPDATE_RESPONSE)
+
+    def test_delete_document_template(self):
+        url = reverse(
+            "karrio.server.documents:document-template-details",
+            kwargs=dict(pk=self.template.pk),
+        )
+
+        response = self.client.delete(url)
+        response_data = json.loads(response.content)
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        # Verify template data is returned (soft delete behavior)
+        self.assertEqual(response_data.get("name"), "Test Template")
+        self.assertEqual(response_data.get("slug"), "test_template")
+        # The template should still be active (or check if it's marked as inactive)
+        self.assertIsNotNone(response_data.get("object_type"))
+
+
+class TestDocumentTemplatesGraphQL(GraphTestCase):
+    def test_query_document_templates(self):
+        # Create a template first
+        DocumentTemplate.objects.create(
+            **{
+                "name": "GraphQL Test Template",
+                "slug": "graphql_test",
+                "template": SAMPLE_HTML_TEMPLATE,
+                "description": "A GraphQL test template",
+                "related_object": "order",
+                "created_by": self.user,
+            }
+        )
+
+        query = """
+        query {
+            document_templates {
+                edges {
+                    node {
+                        id
+                        name
+                        slug
+                        description
+                        related_object
+                        active
+                        object_type
+                    }
+                }
+            }
+        }
+        """
+
+        result = self.query(query)
+        self.assertResponseNoErrors(result)
+
+        templates = result.data["data"]["document_templates"]["edges"]
+        self.assertEqual(len(templates), 1)
+        self.assertEqual(templates[0]["node"]["name"], "GraphQL Test Template")
+        self.assertEqual(templates[0]["node"]["slug"], "graphql_test")
+
+    def test_create_document_template_mutation(self):
+        mutation = """
+        mutation CreateDocumentTemplate($input: CreateDocumentTemplateMutationInput!) {
+            create_document_template(input: $input) {
+                template {
+                    id
+                    name
+                    slug
+                    description
+                    related_object
+                    active
+                }
+                errors {
+                    field
+                    messages
+                }
+            }
+        }
+        """
+
+        variables = {
+            "input": {
+                "name": "GraphQL Created Template",
+                "slug": "graphql_created",
+                "template": SAMPLE_HTML_TEMPLATE,
+                "description": "Created via GraphQL",
+                "related_object": "shipment",
+                "active": True,
+            }
+        }
+
+        result = self.query(mutation, variables=variables)
+        self.assertResponseNoErrors(result)
+
+        created_template = result.data["data"]["create_document_template"]["template"]
+        self.assertEqual(created_template["name"], "GraphQL Created Template")
+        self.assertEqual(created_template["slug"], "graphql_created")
+        self.assertTrue(created_template["active"])
+
+    def test_update_document_template_mutation(self):
+        # Create a template first
+        template = DocumentTemplate.objects.create(
+            **{
+                "name": "Original Template",
+                "slug": "original",
+                "template": SAMPLE_HTML_TEMPLATE,
+                "description": "Original description",
+                "related_object": "shipment",
+                "created_by": self.user,
+            }
+        )
+
+        mutation = """
+        mutation UpdateDocumentTemplate($input: UpdateDocumentTemplateMutationInput!) {
+            update_document_template(input: $input) {
+                template {
+                    id
+                    name
+                    description
+                    active
+                }
+                errors {
+                    field
+                    messages
+                }
+            }
+        }
+        """
+
+        variables = {
+            "input": {
+                "id": template.id,
+                "name": "Updated Template",
+                "description": "Updated description",
+                "active": False,
+            }
+        }
+
+        result = self.query(mutation, variables=variables)
+        self.assertResponseNoErrors(result)
+
+        updated_template = result.data["data"]["update_document_template"]["template"]
+        self.assertEqual(updated_template["name"], "Updated Template")
+        self.assertEqual(updated_template["description"], "Updated description")
+        self.assertFalse(updated_template["active"])
+
+
+# Test Data and Fixtures
+SAMPLE_HTML_TEMPLATE = """
+<title>{{ title | default('Test Document') }}</title>
+"""
+
+DOCUMENT_TEMPLATE_DATA = {
+    "name": "Test Invoice Template",
+    "slug": "test_invoice",
+    "template": SAMPLE_HTML_TEMPLATE,
+    "description": "A test invoice template",
+    "related_object": "shipment",
+    "active": True,
+    "metadata": {"doc_type": "invoice", "version": "1.0"},
+    "options": {"page_size": "A4", "orientation": "portrait"},
+}
+
+DOCUMENT_TEMPLATE_RESPONSE = {
+    "id": ANY,
+    "object_type": "document-template",
+    "name": "Test Invoice Template",
+    "slug": "test_invoice",
+    "template": SAMPLE_HTML_TEMPLATE,
+    "description": "A test invoice template",
+    "related_object": "shipment",
+    "active": True,
+    "metadata": {"doc_type": "invoice", "version": "1.0"},
+    "options": {"page_size": "A4", "orientation": "portrait"},
+    "preview_url": ANY,
+}
+
+DOCUMENT_TEMPLATE_DETAIL_RESPONSE = {
+    "active": True,
+    "description": "A test template",
+    "id": ANY,
+    "metadata": {"doc_type": "invoice"},
+    "name": "Test Template",
+    "object_type": "document-template",
+    "options": {"page_size": "A4"},
+    "related_object": "shipment",
+    "slug": "test_template",
+    "template": SAMPLE_HTML_TEMPLATE,
+    "preview_url": ANY,
+}
+
+DOCUMENT_TEMPLATE_UPDATE_DATA = {
+    "name": "Updated Test Template",
+    "description": "An updated test template",
+    "active": False,
+    "metadata": {"doc_type": "commercial_invoice", "version": "2.0"},
+}
+
+DOCUMENT_TEMPLATE_UPDATE_RESPONSE = {
+    "id": ANY,
+    "object_type": "document-template",
+    "name": "Updated Test Template",
+    "slug": "test_template",
+    "template": SAMPLE_HTML_TEMPLATE,
+    "description": "An updated test template",
+    "related_object": "shipment",
+    "active": False,
+    "metadata": {"doc_type": "commercial_invoice", "version": "2.0"},
+    "options": {"page_size": "A4"},
+    "preview_url": ANY,
+}

karrio/server/documents/tests.py

@@ -0,0 +1,182 @@
+import json
+from django.test import TestCase
+from rest_framework.test import APIClient
+from rest_framework import status
+from unittest.mock import patch
+
+from karrio.server.documents.generator import Documents, TemplateRenderingError
+
+
+class DocumentGenerationErrorHandlingTest(TestCase):
+    def setUp(self):
+        self.client = APIClient()
+        # Mock authentication for testing
+        with patch('karrio.server.core.views.api.APIView.permission_classes', []):
+            pass
+
+    def test_template_with_undefined_variable_returns_error(self):
+        """Test that template with undefined variables returns proper error message"""
+        template = "<div>{{ shipment.shipper.address_line1 }}</div>"
+        data = {
+            "template": template,
+            "doc_format": "html",
+            "doc_name": "Test Document",
+            "data": {
+                "object": {"id": "test123"},
+                # Note: no shipment data provided, so shipment.shipper.address_line1 will be undefined
+            }
+        }
+
+        # Mock the permission check
+        with patch('karrio.server.core.views.api.APIView.check_permissions'):
+            response = self.client.post(
+                '/v1/documents/generate',
+                data=json.dumps(data),
+                content_type='application/json'
+            )
+
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertIn('errors', response.json())
+        self.assertIn('Template variable error', response.json()['errors'][0]['message'])
+        self.assertIn('shipment', response.json()['errors'][0]['message'])
+
+    def test_template_syntax_error_returns_error(self):
+        """Test that template with syntax errors returns proper error message"""
+        template = "<div>{{ unclosed_tag</div>"  # Missing closing }}
+        data = {
+            "template": template,
+            "doc_format": "html",
+            "doc_name": "Test Document",
+            "data": {"test": "data"}
+        }
+
+        with patch('karrio.server.core.views.api.APIView.check_permissions'):
+            response = self.client.post(
+                '/v1/documents/generate',
+                data=json.dumps(data),
+                content_type='application/json'
+            )
+
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertIn('errors', response.json())
+        self.assertIn('Template syntax error', response.json()['errors'][0]['message'])
+
+    def test_missing_template_returns_error(self):
+        """Test that missing template returns proper error message"""
+        data = {
+            "doc_format": "html",
+            "doc_name": "Test Document",
+            "data": {"test": "data"}
+            # Note: no template or template_id provided
+        }
+
+        with patch('karrio.server.core.views.api.APIView.check_permissions'):
+            response = self.client.post(
+                '/v1/documents/generate',
+                data=json.dumps(data),
+                content_type='application/json'
+            )
+
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertIn('errors', response.json())
+        self.assertEqual(
+            response.json()['errors'][0]['message'],
+            'template or template_id is required'
+        )
+
+    def test_valid_template_with_data_succeeds(self):
+        """Test that valid template with proper data succeeds"""
+        template = "<div>Hello {{ name }}!</div>"
+        data = {
+            "template": template,
+            "doc_format": "html",
+            "doc_name": "Test Document",
+            "data": {
+                "name": "World",
+                "shipment": {
+                    "shipper": {"address_line1": "123 Test St"}
+                }
+            }
+        }
+
+        # Mock PDF generation to avoid WeasyPrint dependency in tests
+        with patch('karrio.server.core.views.api.APIView.check_permissions'), \
+             patch('karrio.server.documents.generator.weasyprint.HTML') as mock_html:
+
+            # Mock the PDF generation
+            mock_buffer = b"fake pdf content"
+            mock_html.return_value.write_pdf.return_value = None
+
+            # Patch the buffer creation
+            with patch('karrio.server.documents.generator.io.BytesIO') as mock_bytesio:
+                mock_bytesio.return_value.getvalue.return_value = mock_buffer
+
+                response = self.client.post(
+                    '/v1/documents/generate',
+                    data=json.dumps(data),
+                    content_type='application/json'
+                )
+
+        # Should succeed (201) or fail gracefully with a proper error message
+        self.assertIn(response.status_code, [status.HTTP_201_CREATED, status.HTTP_400_BAD_REQUEST])
+
+        if response.status_code == status.HTTP_400_BAD_REQUEST:
+            # If it fails, it should be with a proper error message, not a 500
+            self.assertIn('errors', response.json())
+            error_message = response.json()['errors'][0]['message']
+            # Should not be a generic "internal server error"
+            self.assertNotIn('Internal server error', error_message)
+
+    def test_template_rendering_error_direct(self):
+        """Test TemplateRenderingError class directly"""
+        try:
+            # Test with a template that has undefined variables
+            Documents.generate(
+                template="<div>{{ undefined_var.nested.property }}</div>",
+                data={"some_data": "test"}
+            )
+            self.fail("Should have raised TemplateRenderingError")
+        except TemplateRenderingError as e:
+            self.assertIn("Template variable error", e.message)
+            self.assertIn("undefined_var", e.message)
+            self.assertIn("Available variables", e.message)
+        except Exception as e:
+            self.fail(f"Should have raised TemplateRenderingError, got {type(e).__name__}: {e}")
+
+
+class DocumentGenerationContextTest(TestCase):
+    """Test that data contexts are properly handled"""
+
+    def test_shipment_context_properly_passed(self):
+        """Test that shipment data is properly passed to template context"""
+        template = "<div>{{ shipment.shipper.address_line1 }}</div>"
+        data = {
+            "shipment": {
+                "shipper": {"address_line1": "123 Test Street"}
+            }
+        }
+
+        try:
+            # This should work without errors
+            result = Documents.generate(template, data=data)
+            # If we get here, the context was properly passed
+            self.assertIsNotNone(result)
+        except TemplateRenderingError as e:
+            # If it fails, it should be due to PDF generation, not template rendering
+            if "PDF generation error" not in e.message:
+                self.fail(f"Template rendering failed: {e.message}")
+
+    def test_generic_context_fallback(self):
+        """Test that generic context fallback works for arbitrary data"""
+        template = "<div>{{ custom_field }}</div>"
+        data = {
+            "custom_field": "test value"
+        }
+
+        try:
+            result = Documents.generate(template, data=data)
+            self.assertIsNotNone(result)
+        except TemplateRenderingError as e:
+            # Should work for simple templates
+            if "PDF generation error" not in e.message:
+                self.fail(f"Template rendering failed: {e.message}")

karrio/server/documents/urls.py

@@ -0,0 +1,11 @@
+"""
+karrio server documents module urls
+"""
+
+from django.urls import include, path
+
+app_name = "karrio.server.documents"
+urlpatterns = [
+    path("", include("karrio.server.documents.views.printers")),
+    path("v1/", include("karrio.server.documents.views.templates")),
+]