Improve tests

README.md

@@ -31,7 +31,7 @@ Set the correct env in VS Code with:
 ### Starting backend 
 
 Database
-`docker compose up --profile dev -d `
+`docker compose up -d `
 
 FastAPI in docker
 `docker run --name=pecuny --rm -dp 8000:8000 --env-file .env pecuny`

app/database.py

@@ -8,44 +8,50 @@
 
 
 class Database:
-    def __init__(self, url):
-        self.session = None
-        self.engine = None
+    def __init__(self, url: str) -> None:
+        """
+        Initializer/Constructor for Database class.
+
+        Parameters:
+        url: str - The URL of the database.
+        """
         self.url = url
+        self.engine = None
+        self.session = None
 
     async def init(self):
-        """Initialize the database connection.
+        """
+        Initializes the database connection.
 
         Args:
-            self
+            self: The instance of the class.
 
         Returns:
             None
-
-        Raises:
-            None
         """
-        # closes connections if a session is created,
-        # so as not to create repeated connections
+
         if self.session:
             await self.session.close()
 
         self.engine = create_async_engine(self.url, future=True)
-        self.session = self.get_session()
-
-    def get_session(self) -> AsyncSession:
-        """Get the database session.
+        self.session = await self.get_session()
 
-        Args:
-            self
+    async def get_session(self) -> AsyncSession:
+        """
+        Creates and provides a new database session.
 
         Returns:
-            AsyncSession: The database session.
-
-        Raises:
-            None
+        AsyncSession: A database session
         """
-        return sessionmaker(self.engine, expire_on_commit=False, class_=AsyncSession)()
+        session_factory = sessionmaker(
+            self.engine, expire_on_commit=False, class_=AsyncSession
+        )
+        async with session_factory() as session:
+            try:
+                return session
+            except Exception as e:
+                await session.rollback()
+                raise e
 
 
 async def get_user_db():

app/main.py

@@ -1,4 +1,5 @@
 import os
+from contextlib import asynccontextmanager
 
 import arel
 from fastapi import FastAPI, Request, status
@@ -20,7 +21,26 @@
 from app.utils import BreadcrumbBuilder
 from app.utils.exceptions import UnauthorizedPageException
 
-app = FastAPI()
+
+@asynccontextmanager
+async def lifespan(_api_app: FastAPI):
+    """
+    Context manager for managing the lifespan of the FastAPI application.
+
+    Args:
+        app (FastAPI): The FastAPI application instance.
+
+    Yields:
+        None
+
+    """
+
+    await db.init()
+    yield
+    await db.session.close()
+
+
+app = FastAPI(lifespan=lifespan)
 logger = get_logger(__name__)
 
 app.mount("/static", StaticFiles(directory="static"), name="static")
@@ -161,38 +181,6 @@ async def page_not_found_exception_handler(request: Request, exc: HTTPException)
     )
 
 
-@app.on_event("startup")
-async def startup_event():
-    """Event handler for the startup event.
-
-    Args:
-        None
-
-    Returns:
-        None
-
-    Raises:
-        None
-    """
-    await db.init()
-
-
-@app.on_event("shutdown")
-async def shutdown_event():
-    """Event handler for the shutdown event.
-
-    Args:
-        None
-
-    Returns:
-        None
-
-    Raises:
-        None
-    """
-    await db.session.close()
-
-
 for route in router_list:
     app.include_router(
         route["router"], prefix=route.get("prefix", ""), tags=route.get("tags", [])

app/repository.py

@@ -1,76 +1,149 @@
 from datetime import datetime
-from typing import List, Type, TypeVar
+from typing import List, Optional, Tuple, Type, TypeVar
 
+from sqlalchemy import Select, text
 from sqlalchemy import update as sql_update
-from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.future import select
 from sqlalchemy.orm import joinedload, selectinload
+from sqlalchemy.orm.attributes import InstrumentedAttribute
 
 from app.database import db
 from app.models import BaseModel
+from app.utils.enums import DatabaseFilterOperator
 
 from . import models
 
 ModelT = TypeVar("ModelT", bound=BaseModel)
 
 
-async def get_all(cls: Type[ModelT]) -> List[ModelT]:
+def load_relationships(query: Select, relationships: InstrumentedAttribute = None):
+    """Apply loading options for specified relationships to a query.
+
+    Args:
+        cls: The model class.
+        query: The SQLAlchemy query object.
+        *relationships: Class-bound attributes representing relationships to load.
+
+    Returns:
+        The modified query with loading options applied.
+    """
+    if relationships:
+        options = [selectinload(rel) for rel in relationships]
+        query = query.options(*options)
+    return query
+
+
+async def get_all(
+    cls: Type, load_relationships_list: Optional[List[InstrumentedAttribute]] = None
+) -> List[ModelT]:
     """Retrieve all instances of the specified model from the database.
 
     Args:
         cls: The type of the model.
+        load_relationships: Optional list of relationships to load.
 
     Returns:
         List[ModelT]: A list of instances of the specified model.
-
-    Raises:
-        None
     """
     q = select(cls)
+    q = load_relationships(q, load_relationships_list)
     result = await db.session.execute(q)
-    result.unique()
-    return result.scalars().all()
+    return result.unique().scalars().all()
 
 
-async def filter_by(cls: Type[ModelT], attribute: str, value: str) -> List[ModelT]:
-    """Filter instances of the specified model by the given attribute and value.
+async def get(
+    cls: Type,
+    instance_id: int,
+    load_relationships_list: Optional[List[InstrumentedAttribute]] = None,
+) -> ModelT:
+    """Retrieve an instance of the specified model by its ID.
 
     Args:
         cls: The type of the model.
+        instance_id: The ID of the instance to retrieve.
+        load_relationships: Optional list of relationships to load.
+
+    Returns:
+        ModelT: The instance of the specified model with the given ID.
+    """
+    q = select(cls).where(cls.id == instance_id)
+    q = load_relationships(q, load_relationships_list)
+    result = await db.session.execute(q)
+    return result.scalars().first()
+
+
+async def filter_by(
+    cls: Type[ModelT],
+    attribute: str,  # TODO: InstrumentedAttribute,
+    value: str,
+    operator: DatabaseFilterOperator = DatabaseFilterOperator.EQUAL,
+    load_relationships_list: Optional[List[str]] = None,
+) -> List[ModelT]:
+    """
+    Filters the records of a given model by a specified attribute and value.
+
+    Args:
+        cls: The model class.
         attribute: The attribute to filter by.
         value: The value to filter with.
+        operator: The operator to use for the filter (default: EQUAL).
 
     Returns:
-        List[ModelT]: A list of instances of the specified model that match the filter criteria.
+        List[ModelT]: The filtered records.
 
     Raises:
         None
     """
-    query = select(cls).where(getattr(cls, attribute) == value)
-    result = await db.session.execute(query)
-    return result.scalars().all()
+    # TODO: Update for InstrumentedAttribute
+    # condition = text(f"{attribute.key} {operator.value} :val")
+    condition = text(f"{attribute} {operator.value} :val")
 
+    q = select(cls).where(condition).params(val=value)
+    q = load_relationships(q, load_relationships_list)
 
-async def get(cls: Type[ModelT], instance_id: int, load_relationships=None) -> ModelT:
-    """Retrieve an instance of the specified model by its ID.
+    result = await db.session.execute(q)
+
+    return result.unique().scalars().all()
+
+
+async def filter_by_multiple(
+    cls: Type[ModelT],
+    conditions: List[Tuple[str, str, DatabaseFilterOperator]],
+    load_relationships_list: Optional[List[str]] = None,
+) -> List[ModelT]:
+    """
+    Filters the records of a given model by multiple attributes and values.
 
     Args:
-        cls: The type of the model.
-        instance_id: The ID of the instance to retrieve.
-        load_relationships: Optional list of relationships to load.
+        cls: The model class.
+        conditions: A list of tuples where each tuple contains an attribute to filter by,
+                    a value to filter with, and an optional operator
+                    (if not provided, EQUAL is used).
+        load_relationships_list: Optional list of relationships to load.
 
     Returns:
-        ModelT: The instance of the specified model with the given ID.
-
-    Raises:
-        None
+        List[Model]: The filtered records.
     """
-    stmt = select(cls).where(cls.id == instance_id)
-    if load_relationships:
-        options = [selectinload(rel) for rel in load_relationships]
-        stmt = stmt.options(*options)
-    result = await db.session.execute(stmt)
-    return result.scalars().first()
+
+    # Construct the WHERE clause
+    where_conditions = []
+    params = {}
+    for i, (attribute, value, operator) in enumerate(conditions):
+        param_name = f"val{i}"
+        where_conditions.append(text(f"{attribute} {operator.value} :{param_name}"))
+        params[param_name] = value
+
+    q = select(cls)
+    if where_conditions:
+        for condition in where_conditions:
+            q = q.where(condition)
+    q = q.params(**params)
+
+    q = load_relationships(q, load_relationships_list)
+
+    result = await db.session.execute(q)
+
+    return result.scalars().unique().all()
 
 
 async def get_scheduled_transactions_from_period(
@@ -157,21 +230,6 @@ async def save(obj: Type[ModelT]) -> None:
     db.session.add(obj)
 
 
-async def get_session() -> AsyncSession:
-    """Get the database session.
-
-    Args:
-        None
-
-    Returns:
-        AsyncSession: The database session.
-
-    Raises:
-        None
-    """
-    return db.session
-
-
 async def commit(session) -> None:
     """Commit the changes made in the session to the database.
 
@@ -222,6 +280,14 @@ async def delete(obj: Type[ModelT]) -> None:
     Raises:
         None
     """
+
+    # TODO: Test this
+    # if isinstance(obj, list):
+    #     for object in obj:
+    #         db.session.delete(object)
+    #     return
+
+    # TODO: Await needed?
     await db.session.delete(obj)
 
 

app/routers/accounts.py

@@ -12,15 +12,17 @@
 from app import transaction_manager as tm
 from app.auth_manager import current_active_user
 from app.routers.dashboard import router as dashboard_router
-from app.services import accounts as service
-from app.services import transactions as transaction_service
+from app.services.accounts import AccountService
+from app.services.transactions import TransactionService
 from app.utils import PageRouter
 from app.utils.account_utils import get_account_list_template
 from app.utils.enums import FeedbackType
 from app.utils.template_utils import add_breadcrumb, render_template, set_feedback
 
 PREFIX = f"{dashboard_router.prefix}/accounts"
 router = PageRouter(prefix=PREFIX, tags=["Accounts"])
+service = AccountService()
+transaction_service = TransactionService()
 
 
 async def handle_account_route(