Merge pull request #34 from febus982/merge_sync_and_async_tests

Merge sync and async tests

Author: febus982

sqlalchemy_bind_manager/_repository/async_.py

@@ -16,7 +16,7 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from .._bind_manager import SQLAlchemyAsyncBind
-from .._transaction_handler import AsyncSessionHandler
+from .._session_handler import AsyncSessionHandler
 from ..exceptions import InvalidConfig, ModelNotFound
 from .base_repository import (
     BaseRepository,

sqlalchemy_bind_manager/_repository/sync.py

@@ -16,7 +16,7 @@
 from sqlalchemy.orm import Session
 
 from .._bind_manager import SQLAlchemyBind
-from .._transaction_handler import SessionHandler
+from .._session_handler import SessionHandler
 from ..exceptions import InvalidConfig, ModelNotFound
 from .base_repository import (
     BaseRepository,

…emy_bind_manager/_transaction_handler.py …alchemy_bind_manager/_session_handler.pysqlalchemy_bind_manager/_transaction_handler.py renamed to sqlalchemy_bind_manager/_session_handler.py sqlalchemy_bind_manager/_transaction_handler.py renamed to sqlalchemy_bind_manager/_session_handler.py

@@ -5,7 +5,7 @@
 from sqlalchemy.orm import Session
 
 from sqlalchemy_bind_manager._bind_manager import SQLAlchemyAsyncBind, SQLAlchemyBind
-from sqlalchemy_bind_manager._transaction_handler import (
+from sqlalchemy_bind_manager._session_handler import (
     AsyncSessionHandler,
     SessionHandler,
 )

sqlalchemy_bind_manager/_unit_of_work/__init__.py

@@ -1,8 +1,25 @@
+import inspect
+import os
+from contextlib import _AsyncGeneratorContextManager, asynccontextmanager
+from typing import Tuple, Type, Union
 from uuid import uuid4
 
 import pytest
+from sqlalchemy import Column, ForeignKey, Integer, String
+from sqlalchemy.orm import clear_mappers, relationship
 
 from sqlalchemy_bind_manager import SQLAlchemyAsyncConfig, SQLAlchemyConfig
+from sqlalchemy_bind_manager._bind_manager import (
+    SQLAlchemyAsyncBind,
+    SQLAlchemyBind,
+    SQLAlchemyBindManager,
+)
+from sqlalchemy_bind_manager._repository import (
+    SQLAlchemyAsyncRepository,
+    SQLAlchemyRepository,
+)
+from sqlalchemy_bind_manager._session_handler import AsyncSessionHandler, SessionHandler
+from sqlalchemy_bind_manager.repository import AsyncUnitOfWork, UnitOfWork
 
 
 @pytest.fixture
@@ -25,3 +42,146 @@ def multiple_config():
             engine_options=dict(connect_args={"check_same_thread": False}),
         ),
     }
+
+
+@pytest.fixture()
+def sync_async_wrapper():
+    """
+    Tiny wrapper to allow calling sync and async methods using await.
+
+    :return:
+    """
+
+    async def f(call):
+        return await call if inspect.iscoroutine(call) else call
+
+    return f
+
+
+@pytest.fixture()
+def sync_async_cm_wrapper():
+    """
+    Tiny wrapper to allow calling sync and async methods using await.
+
+    :return:
+    """
+
+    @asynccontextmanager
+    async def f(cm):
+        if isinstance(cm, _AsyncGeneratorContextManager):
+            async with cm as c:
+                yield c
+        else:
+            with cm as c:
+                yield c
+
+    return f
+
+
+@pytest.fixture
+def sa_manager() -> SQLAlchemyBindManager:
+    test_sync_db_path = f"./{uuid4()}.db"
+    test_async_db_path = f"./{uuid4()}.db"
+    config = {
+        "sync": SQLAlchemyConfig(
+            engine_url=f"sqlite:///{test_sync_db_path}",
+            engine_options=dict(connect_args={"check_same_thread": False}),
+        ),
+        "async": SQLAlchemyAsyncConfig(
+            engine_url=f"sqlite+aiosqlite:///{test_sync_db_path}",
+            engine_options=dict(connect_args={"check_same_thread": False}),
+        ),
+    }
+
+    yield SQLAlchemyBindManager(config)
+    try:
+        os.unlink(test_sync_db_path)
+    except FileNotFoundError:
+        pass
+
+    try:
+        os.unlink(test_async_db_path)
+    except FileNotFoundError:
+        pass
+
+    clear_mappers()
+
+
+@pytest.fixture(params=["sync", "async"])
+def sa_bind(request, sa_manager):
+    return sa_manager.get_bind(request.param)
+
+
+@pytest.fixture
+async def model_classes(sa_bind) -> Tuple[Type, Type]:
+    class ParentModel(sa_bind.model_declarative_base):
+        __tablename__ = "parent_model"
+        # required in order to access columns with server defaults
+        # or SQL expression defaults, subsequent to a flush, without
+        # triggering an expired load
+        __mapper_args__ = {"eager_defaults": True}
+
+        model_id = Column(Integer, primary_key=True, autoincrement=True)
+        name = Column(String)
+
+        children = relationship(
+            "ChildModel",
+            back_populates="parent",
+            cascade="all, delete-orphan",
+            lazy="selectin",
+        )
+
+    class ChildModel(sa_bind.model_declarative_base):
+        __tablename__ = "child_model"
+        # required in order to access columns with server defaults
+        # or SQL expression defaults, subsequent to a flush, without
+        # triggering an expired load
+        __mapper_args__ = {"eager_defaults": True}
+
+        model_id = Column(Integer, primary_key=True, autoincrement=True)
+        parent_model_id = Column(
+            Integer, ForeignKey("parent_model.model_id"), nullable=False
+        )
+        name = Column(String)
+
+        parent = relationship("ParentModel", back_populates="children", lazy="selectin")
+
+    if isinstance(sa_bind, SQLAlchemyBind):
+        sa_bind.registry_mapper.metadata.create_all(sa_bind.engine)
+    else:
+        async with sa_bind.engine.begin() as conn:
+            await conn.run_sync(sa_bind.registry_mapper.metadata.create_all)
+
+    return ParentModel, ChildModel
+
+
+@pytest.fixture
+async def model_class(model_classes: Tuple[Type, Type]) -> Type:
+    return model_classes[0]
+
+
+@pytest.fixture
+def session_handler_class(sa_bind):
+    return (
+        AsyncSessionHandler
+        if isinstance(sa_bind, SQLAlchemyAsyncBind)
+        else SessionHandler
+    )
+
+
+@pytest.fixture
+def repository_class(
+    sa_bind: Union[SQLAlchemyBind, SQLAlchemyAsyncBind]
+) -> Type[Union[SQLAlchemyAsyncRepository, SQLAlchemyRepository]]:
+    base_class = (
+        SQLAlchemyRepository
+        if isinstance(sa_bind, SQLAlchemyBind)
+        else SQLAlchemyAsyncRepository
+    )
+
+    return base_class
+
+
+@pytest.fixture
+def uow_class(sa_bind):
+    return AsyncUnitOfWork if isinstance(sa_bind, SQLAlchemyAsyncBind) else UnitOfWork