feature/T2026-05-016 implementar cargas de tareas en background e implementar y corregir auditoria para datastages

api/customs/tests.py

@@ -3,7 +3,12 @@ from django.urls import reverse
 from rest_framework.test import APITestCase, APIClient
 from rest_framework import status
 from django.contrib.auth import get_user_model
+from django.core.files.uploadedfile import SimpleUploadedFile
+from unittest.mock import patch
+from io import BytesIO
+import zipfile
 from api.organization.models import Organizacion
+from api.licence.models import Licencia
 from .models import Pedimento, TipoOperacion, ProcesamientoPedimento, EDocument
 
 User = get_user_model()
@@ -75,3 +80,147 @@ class CustomsViewsTests(APITestCase):
         self.client.force_authenticate(user=self.admin)
         response = self.client.get(url)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+
+# ---------------------------------------------------------------------------
+# Tests de integración para bulk-create (ViewSetPedimento.bulk_create)
+# Verifica que al re-cargar un pedimento existente sus documentos se actualicen
+# ---------------------------------------------------------------------------
+
+class BulkCreateDocumentReplaceTests(APITestCase):
+    """Verifica que bulk-create actualiza los documentos de pedimentos existentes
+    en vez de ignorarlos, y que no quedan archivos residuales en el storage."""
+
+    PEDIMENTO_APP = "24-01-3420-1234567"
+
+    def setUp(self):
+        self.licencia = Licencia.objects.create(nombre="Lic100GB", almacenamiento=100)
+        self.org = Organizacion.objects.create(
+            nombre="OrgBulkCreate",
+            licencia=self.licencia,
+            is_active=True,
+            is_verified=True,
+        )
+        self.user = User.objects.create_user(
+            username="bulkcreateuser", password="pass", organizacion=self.org
+        )
+        self.pedimento = Pedimento.objects.create(
+            organizacion=self.org,
+            pedimento="1234567",
+            pedimento_app=self.PEDIMENTO_APP,
+        )
+        from api.record.models import DocumentType, Fuente
+        self.doc_type = DocumentType.objects.get_or_create(nombre="Pedimento")[0]
+        # bulk_create usa fuente_id=4 hardcodeado; debe existir en la DB de test
+        Fuente.objects.get_or_create(id=4, defaults={"nombre": "Bulk Create"})
+        self.url = reverse("Pedimento-bulk-create")
+        self.client.force_authenticate(user=self.user)
+
+    def _make_zip(self, files_dict):
+        """Crea un ZIP en memoria. files_dict = {nombre_archivo: contenido_bytes}"""
+        buf = BytesIO()
+        with zipfile.ZipFile(buf, "w") as zf:
+            for name, content in files_dict.items():
+                zf.writestr(name, content)
+        buf.seek(0)
+        return SimpleUploadedFile(
+            f"{self.PEDIMENTO_APP}.zip", buf.read(), content_type="application/zip"
+        )
+
+    def _post_zip(self, files_dict):
+        return self.client.post(
+            self.url,
+            {"contribuyente": "XAXX010101000", "archivos": [self._make_zip(files_dict)]},
+            format="multipart",
+        )
+
+    @patch("api.customs.views.storage_service")
+    def test_existing_pedimento_not_duplicated(self, mock_st):
+        """Re-subir un pedimento existente NO debe crear un segundo Pedimento."""
+        mock_st.save_document_from_path.return_value = "org_1/documents/ped/informe_a1b2c3d4.pdf"
+
+        self._post_zip({"informe.pdf": b"contenido"})
+
+        self.assertEqual(
+            Pedimento.objects.filter(
+                organizacion=self.org, pedimento_app=self.PEDIMENTO_APP
+            ).count(),
+            1,
+        )
+
+    @patch("api.customs.views.storage_service")
+    def test_existing_pedimento_document_replaced_not_duplicated(self, mock_st):
+        """Documento existente con el mismo nombre base se reemplaza, no se duplica."""
+        from api.record.models import Document
+
+        old_path = f"org_1/documents/{self.PEDIMENTO_APP}/informe_a1b2c3d4.pdf"
+        old_doc = Document.objects.create(
+            organizacion=self.org,
+            pedimento=self.pedimento,
+            document_type=self.doc_type,
+            archivo=old_path,
+            size=500,
+            extension="pdf",
+        )
+        new_path = f"org_1/documents/{self.PEDIMENTO_APP}/informe_b5c6d7e8.pdf"
+        mock_st.save_document_from_path.return_value = new_path
+        mock_st.delete_file.return_value = True
+
+        self._post_zip({"informe.pdf": b"contenido actualizado"})
+
+        docs = Document.objects.filter(pedimento=self.pedimento)
+        # Sin duplicados
+        self.assertEqual(docs.count(), 1)
+        # Mismo registro
+        self.assertEqual(docs.first().id, old_doc.id)
+        # Archivo actualizado
+        old_doc.refresh_from_db()
+        self.assertEqual(old_doc.archivo.name, new_path)
+
+    @patch("api.customs.views.storage_service")
+    def test_existing_pedimento_stale_file_deleted_from_storage(self, mock_st):
+        """Al reemplazar un documento, el archivo viejo debe eliminarse del storage."""
+        from api.record.models import Document
+
+        old_path = f"org_1/documents/{self.PEDIMENTO_APP}/informe_a1b2c3d4.pdf"
+        Document.objects.create(
+            organizacion=self.org,
+            pedimento=self.pedimento,
+            document_type=self.doc_type,
+            archivo=old_path,
+            size=500,
+            extension="pdf",
+        )
+        mock_st.save_document_from_path.return_value = f"org_1/documents/{self.PEDIMENTO_APP}/informe_b5c6d7e8.pdf"
+        mock_st.delete_file.return_value = True
+
+        self._post_zip({"informe.pdf": b"contenido"})
+
+        # delete_file debe haberse llamado con la ruta del archivo viejo
+        mock_st.delete_file.assert_called()
+        called_arg = str(mock_st.delete_file.call_args[0][0])
+        self.assertIn("informe_a1b2c3d4", called_arg)
+
+    @patch("api.customs.views.storage_service")
+    def test_existing_pedimento_new_file_added(self, mock_st):
+        """Archivo nuevo en el ZIP se añade al pedimento existente."""
+        from api.record.models import Document
+
+        mock_st.save_document_from_path.return_value = "org_1/documents/ped/nuevo_b5c6d7e8.pdf"
+
+        self._post_zip({"nuevo_documento.pdf": b"contenido nuevo"})
+
+        self.assertGreaterEqual(
+            Document.objects.filter(pedimento=self.pedimento).count(), 1
+        )
+
+    @patch("api.customs.views.storage_service")
+    def test_already_existing_count_in_response(self, mock_st):
+        """La respuesta debe indicar que el pedimento ya existía (already_existing_count >= 1)."""
+        mock_st.save_document_from_path.return_value = "org_1/documents/ped/f_a1b2c3d4.pdf"
+
+        response = self._post_zip({"archivo.pdf": b"contenido"})
+
+        self.assertIn(response.status_code, [status.HTTP_200_OK, status.HTTP_207_MULTI_STATUS, status.HTTP_201_CREATED])
+        data = response.json()
+        self.assertGreaterEqual(data.get("already_existing_count", 0), 1)