✅(ingestion-infrastructure) add metiers repository tests for specifics

Author: Atheane

src/web/infrastructure/repositories/shared/postgres_metier_repository.py

@@ -96,6 +96,14 @@ def get_by_external_id(self, external_id: str) -> Metier:
                 f"Metier with external_id {external_id} not found"
             ) from e
 
+    def get_all(self) -> List[Metier]:
+        metier_models = MetierModel.objects.all()
+        return [model.to_entity() for model in metier_models]
+
+    def filter_by(self, predicate: Dict[str, str], limit: int = 1000) -> List[Metier]:
+        metier_models = MetierModel.objects.filter(**predicate)[:limit]
+        return [model.to_entity() for model in metier_models]
+
     @transaction.atomic
     def get_pending_processing(self, limit: int = 1000) -> List[Metier]:
         qs = (
@@ -113,22 +121,18 @@ def get_pending_processing(self, limit: int = 1000) -> List[Metier]:
 
         return [model.to_entity() for model in qs]
 
-    def get_all(self) -> List[Metier]:
-        metier_models = MetierModel.objects.all()
-        return [model.to_entity() for model in metier_models]
-
-    def filter_by(self, predicate: Dict[str, str], limit: int = 1000) -> List[Metier]:
-        metier_models = MetierModel.objects.filter(**predicate)[:limit]
-        return [model.to_entity() for model in metier_models]
-
     def mark_as_processed(self, metiers_list: List[Metier]) -> int:
-        metier_ids = [metier.id for metier in metiers_list]
-        return MetierModel.objects.filter(id__in=metier_ids).update(
-            processing=False, processed_at=timezone.now()
-        )
+        try:
+            return MetierModel.objects.filter(
+                id__in=[obj.id for obj in metiers_list]
+            ).update(processed_at=timezone.now(), processing=False)
+        except Exception as e:
+            raise DatabaseError(f"Database error during update: {str(e)}") from e
 
     def mark_as_pending(self, metiers_list: List[Metier]) -> int:
-        metier_ids = [metier.id for metier in metiers_list]
-        return MetierModel.objects.filter(id__in=metier_ids).update(
-            processing=True, processed_at=None
-        )
+        try:
+            return MetierModel.objects.filter(
+                id__in=[obj.id for obj in metiers_list]
+            ).update(processing=False)
+        except Exception as e:
+            raise DatabaseError(f"Database error during update: {str(e)}") from e

src/web/tests/factories/metier_factory.py

@@ -1,6 +1,8 @@
+from datetime import datetime
 from typing import List, Optional
 from uuid import UUID, uuid4
 
+from django.utils import timezone
 from faker import Faker
 from polyfactory.factories import DataclassFactory
 
@@ -91,6 +93,10 @@ def create_model(
         activites: Optional[List[str]] = None,
         conditions_particulieres: Optional[List[str]] = None,
         offer_family_code: Optional[str] = None,
+        processing: bool = False,
+        processed_at: Optional[datetime] = None,
+        archived_at: Optional[datetime] = None,
+        updated_at: Optional[datetime] = None,
     ) -> MetierModel:
 
         metier = MetierFactory.create_entity(
@@ -106,8 +112,19 @@ def create_model(
         )
 
         metier_model = MetierModel.from_entity(metier)
+        metier_model.processing = processing
+        metier_model.processed_at = processed_at
+        metier_model.archived_at = archived_at
+        metier_model.updated_at = updated_at
+
         metier_model.save()
 
+        if updated_at is not None:
+            MetierModel.objects.filter(pk=metier_model.pk).update(
+                updated_at=timezone.make_aware(updated_at)
+            )
+            metier_model.refresh_from_db()
+
         return metier_model
 
     @staticmethod

src/web/tests/shared/integration/repository/test_postgres_metiers_repository.py

@@ -0,0 +1,96 @@
+from datetime import datetime
+
+import pytest
+from dateutil.relativedelta import relativedelta
+from faker import Faker
+
+from domain.entities.metier import Metier
+from infrastructure.django_apps.shared.models.metier import MetierModel
+from infrastructure.gateways.shared.logger import LoggerService
+from infrastructure.repositories.shared.postgres_metier_repository import (
+    PostgresMetierRepository,
+)
+from tests.factories.metier_factory import MetierFactory
+
+fake = Faker()
+NOW = datetime.now()
+DAY_AGO = NOW - relativedelta(days=1)
+
+
+@pytest.fixture(name="repository")
+def repository_fixture():
+    return PostgresMetierRepository(LoggerService())
+
+
+class TestGetPendingProcessing:
+    def test_excluded_items(self, db, repository):
+        MetierFactory.create_model(archived_at=NOW)
+        MetierFactory.create_model(processing=True)
+        MetierFactory.create_model(processed_at=NOW, updated_at=DAY_AGO)
+
+        assert repository.get_pending_processing() == []
+
+    def test_get_pending_items_with_logical_lock(self, db, repository):
+        never_processed = MetierFactory.create_model()
+        updated_after_processed = MetierFactory.create_model(
+            processed_at=DAY_AGO, updated_at=NOW
+        )
+
+        entities = repository.get_pending_processing()
+        assert {e.id for e in entities} == {
+            never_processed.id,
+            updated_after_processed.id,
+        }
+
+        for entity in entities:
+            assert isinstance(entity, Metier)
+
+    def test_limit(self, db, repository):
+        MetierFactory.create_model_batch(2)
+
+        entities = repository.get_pending_processing(limit=1)
+        assert len(entities) == 1
+        assert MetierModel.objects.filter(processing=True).count() == 1
+        assert MetierModel.objects.filter(processing=False).count() == 1
+
+
+def test_mark_as_processed(db, repository):
+    concours_list = [
+        MetierFactory.create_model(processing=True).to_entity(),
+        MetierFactory.create_model(processing=False).to_entity(),
+    ]
+    undesired_concours = MetierFactory.create_model(processing=True).to_entity()
+
+    count = repository.mark_as_processed(concours_list)
+    assert count == len(concours_list)
+
+    model_objects = MetierModel.objects.filter(
+        processing=False, processed_at__isnull=False
+    )
+    assert set(model_objects.values_list("id", flat=True)) == {
+        concours.id for concours in concours_list
+    }
+
+    undesired_model_objects = MetierModel.objects.get(
+        processing=True, processed_at__isnull=True
+    )
+    assert undesired_model_objects.id == undesired_concours.id
+
+
+def test_mark_as_pending(db, repository):
+    metiers_list = [
+        MetierFactory.create_model(processing=True).to_entity(),
+        MetierFactory.create_model(processing=False).to_entity(),
+    ]
+    undesired_metiers = MetierFactory.create_model(processing=True).to_entity()
+
+    count = repository.mark_as_pending(metiers_list)
+    assert count == len(metiers_list)
+
+    model_objects = MetierModel.objects.filter(processing=False)
+    assert set(model_objects.values_list("id", flat=True)) == {
+        metier.id for metier in metiers_list
+    }
+
+    undesired_model_objects = MetierModel.objects.get(processing=True)
+    assert undesired_model_objects.id == undesired_metiers.id