python-general-be-lib 0.12.0__tar.gz → 0.12.1__tar.gz

{python_general_be_lib-0.12.0 → python_general_be_lib-0.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-general-be-lib
-Version: 0.12.0
+Version: 0.12.1
 Summary: General purpose backend library — SQLAlchemy CRUD/Geometry repositories, FastAPI exceptions, Pydantic base models, Keycloak JWT auth, logger utilities.
 Author-email: Andrea Di Placido <a.diplacido@arpes.it>, "Arpes S.r.l." <it.admin@arpes.it>
 License: MIT

{python_general_be_lib-0.12.0 → python_general_be_lib-0.12.1}/general/interface/repository/crud_repository.py

@@ -169,14 +169,23 @@ class CrudRepository[Entity: Base | Type[Base]]:
         return _reduced_model(self.entity, frozenset(selected_columns))
 
     def _handle_exception(self, session: Session, e: Exception):
-        """Close the session, log the error and raise an HTTP-friendly exception.
+        """Roll back and close the session, log the error and raise an HTTP-friendly exception.
 
         An ``OperationalError`` becomes a ``ServiceUnavailableException``, a
         ``NoResultFound`` an ``EntityNotFoundException``, a ``DataError`` or an
         ``IntegrityError`` a ``BadRequestException``; any other exception is re-raised as is.
 
+        ``close`` alone already rolls back the database transaction. What the explicit
+        ``rollback`` adds is the expiry of the ORM instances: an entity still held by the
+        caller raises ``DetachedInstanceError`` on access instead of exposing values that
+        were flushed but never committed. It runs on every error, a failed SELECT included,
+        since on PostgreSQL that aborts the transaction as well. An external session is
+        rolled back and closed too, so the caller's transaction is lost. A failure of the
+        rollback itself is logged and does not replace ``e``, and the session is closed
+        anyway.
+
         Args:
-            session (Session): Session to close.
+            session (Session): Session to roll back and close.
             e (Exception): Caught exception to handle.
 
         Raises:
@@ -184,6 +193,11 @@ class CrudRepository[Entity: Base | Type[Base]]:
             EntityNotFoundException: If no record matches.
             BadRequestException: If the data is malformed or violates a constraint.
         """
+        try:
+            session.rollback()
+        except Exception:
+            # un rollback fallito non deve sostituire l'errore originale, né saltare la close
+            logging.exception("Rollback failed")
         session.close()
         logging.error(e)
         raise_http_exception(e)
@@ -195,12 +209,13 @@ class CrudRepository[Entity: Base | Type[Base]]:
             session (Session): Session to commit.
 
         Raises:
-            ServiceUnavailableException | BadRequestException: On error during the commit.
+            ServiceUnavailableException | BadRequestException: On error during the commit,
+                after rolling back and closing the session.
         """
         try:
             session.commit()
         except Exception as e:
-            self._handle_exception(session, e)
+            self._handle_exception(session=session, e=e)
 
     def _flush(self, session: Session):
         """Flush the session, handling the possible exceptions.
@@ -214,12 +229,13 @@ class CrudRepository[Entity: Base | Type[Base]]:
             session (Session): Session to flush.
 
         Raises:
-            ServiceUnavailableException | BadRequestException: On error during the flush.
+            ServiceUnavailableException | BadRequestException: On error during the flush,
+                after rolling back and closing the session.
         """
         try:
             session.flush()
         except Exception as e:
-            self._handle_exception(session, e)
+            self._handle_exception(session=session, e=e)
 
     def _entity_has_columns(self, *columns: str, entity: Type[Base] | Base = None) -> bool:
         """Check that every given name is a column of the entity.
@@ -441,7 +457,7 @@ class CrudRepository[Entity: Base | Type[Base]]:
             try:
                 entity = session.get(self.entity, values)
             except Exception as e:
-                self._handle_exception(session, e)
+                self._handle_exception(session=session, e=e)
             else:
                 return [entity] if entity is not None else []
 
@@ -607,7 +623,7 @@ class CrudRepository[Entity: Base | Type[Base]]:
         try:
             session.add_all(entities)
         except Exception as e:
-            self._handle_exception(session, e)
+            self._handle_exception(session=session, e=e)
         return self._return(session=session, entities=entities, keep_open=keep_open, commit=True, parsing_model=parsing_model)
 
     def update(self, session: Session = None, where: dict[str, Any] = None, returning: bool = True, parsing_model: Type[BaseModel] | BaseModel = None, **kwargs) -> list[Entity] | list[BaseModel]:
@@ -1049,9 +1065,9 @@ class CrudRepository[Entity: Base | Type[Base]]:
         """Execute a SQLAlchemy statement and return the result as it is.
 
         The method owns the error handling and nothing else: every exception goes to
-        ``_handle_exception``, which closes the session and maps the error to an HTTP
-        status. Reading the result is left to the caller, which is the only one knowing the
-        shape it needs — ``.scalars().all()`` for entities, ``.scalar()`` for an aggregate,
+        ``_handle_exception``, which rolls back and closes the session and maps the error
+        to an HTTP status. Reading the result is left to the caller, which is the only one
+        knowing the shape it needs — ``.scalars().all()`` for entities, ``.scalar()`` for an aggregate,
         ``.all()`` for the multi-column rows of a statement built with ``add_columns``,
         ``.rowcount`` for a DML without ``RETURNING``. The result is bound to the session,
         so it has to be consumed before the session is closed. ``Session.execute`` returns
@@ -1076,6 +1092,6 @@ class CrudRepository[Entity: Base | Type[Base]]:
         try:
             result = session.execute(statement=stmt, params=values)
         except Exception as e:
-            self._handle_exception(session, e)
+            self._handle_exception(session=session, e=e)
         else:
             return result

{python_general_be_lib-0.12.0 → python_general_be_lib-0.12.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-general-be-lib"
-version = "0.12.0"
+version = "0.12.1"
 description = "General purpose backend library — SQLAlchemy CRUD/Geometry repositories, FastAPI exceptions, Pydantic base models, Keycloak JWT auth, logger utilities."
 readme = "README.md"
 license = { text = "MIT" }

{python_general_be_lib-0.12.0 → python_general_be_lib-0.12.1}/python_general_be_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-general-be-lib
-Version: 0.12.0
+Version: 0.12.1
 Summary: General purpose backend library — SQLAlchemy CRUD/Geometry repositories, FastAPI exceptions, Pydantic base models, Keycloak JWT auth, logger utilities.
 Author-email: Andrea Di Placido <a.diplacido@arpes.it>, "Arpes S.r.l." <it.admin@arpes.it>
 License: MIT

{python_general_be_lib-0.12.0 → python_general_be_lib-0.12.1}/python_general_be_lib.egg-info/SOURCES.txt

@@ -75,6 +75,7 @@ tests/test_ordinamento.py
 tests/test_pipeline_handler.py
 tests/test_query_count.py
 tests/test_retrieve_mapper.py
+tests/test_rollback.py
 tests/test_smoke_crud.py
 tests/test_softdelete.py
 tests/test_sql_snapshot.py

python_general_be_lib-0.12.1/tests/test_rollback.py

@@ -0,0 +1,85 @@
+"""Rollback di ``CrudRepository._handle_exception``.
+
+``Session.close()`` annulla già la transazione sul database: quello che il
+``rollback()`` esplicito aggiunge è la scadenza delle istanze ORM. Senza, un'entità
+rimasta in mano al chiamante resta leggibile con i valori del ``flush`` mai
+confermati; con, la lettura alza ``DetachedInstanceError``. Il rollback gira su ogni
+errore, SELECT compresa, e un suo fallimento non deve coprire l'errore originale.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import pytest
+from sqlalchemy import select, text
+from sqlalchemy.engine import Engine
+from sqlalchemy.exc import IntegrityError, ProgrammingError
+from sqlalchemy.orm import Session
+from sqlalchemy.orm.exc import DetachedInstanceError
+
+from general.exception.crud_exceptions import BadRequestException, ServiceUnavailableException
+from general.interface.repository.crud_repository import CrudRepository
+from models import Prodotto, ProdottoModel, prodotto_repository
+
+
+@pytest.fixture
+def repo(engine: Engine) -> CrudRepository:
+    repository = prodotto_repository(engine)
+    repository.insert(models=[ProdottoModel(id=1, codice="pulito")])
+    return repository
+
+
+def test_errore_di_scrittura_fa_scadere_le_entita_della_sessione_esterna(engine: Engine, repo: CrudRepository) -> None:
+    """Dopo un ``IntegrityError`` l'entità modificata non espone più il valore mai confermato."""
+    sessione = Session(engine)
+    entita = sessione.get(Prodotto, 1)
+    entita.codice = "sporco"
+
+    with pytest.raises(BadRequestException):
+        repo.insert(session=sessione, models=[ProdottoModel(id=1, codice="duplicato")])
+
+    with pytest.raises(DetachedInstanceError):
+        _ = entita.codice
+    assert repo.get(1).codice == "pulito"
+
+
+def test_anche_una_select_fallita_fa_scadere_le_entita(engine: Engine, repo: CrudRepository) -> None:
+    """Su PostgreSQL una SELECT fallita blocca la transazione: il rollback vale anche lì."""
+    sessione = Session(engine)
+    entita = sessione.get(Prodotto, 1)
+    entita.codice = "sporco"
+    sessione.flush()
+
+    # SQLite la segnala come OperationalError (503), PostgreSQL come ProgrammingError (non mappato)
+    with pytest.raises((ServiceUnavailableException, ProgrammingError)):
+        repo.execute(sessione, select(Prodotto).where(text("colonna_inesistente = 1")))
+
+    with pytest.raises(DetachedInstanceError):
+        _ = entita.codice
+    assert repo.get(1).codice == "pulito"
+
+
+class _SessioneConRollbackRotto:
+    """Sessione finta il cui ``rollback`` fallisce, per verificare cosa succede dopo."""
+
+    def __init__(self) -> None:
+        self.chiusa = False
+
+    def rollback(self) -> None:
+        raise RuntimeError("rollback rotto")
+
+    def close(self) -> None:
+        self.chiusa = True
+
+
+def test_un_rollback_fallito_non_copre_l_errore_originale(sqlite_engine: Engine, caplog) -> None:
+    """L'errore originale resta quello mappato, la sessione viene chiusa e il guasto registrato."""
+    repository = prodotto_repository(sqlite_engine)
+    sessione = _SessioneConRollbackRotto()
+
+    with caplog.at_level(logging.ERROR), pytest.raises(BadRequestException):
+        repository._handle_exception(session=sessione, e=IntegrityError("s", None, Exception()))
+
+    assert sessione.chiusa is True
+    assert any(record.exc_info and isinstance(record.exc_info[1], RuntimeError) for record in caplog.records)