Skip to content

Open-source personal finance manager. Self-hosted, privacy-first.

12.6 KB
Raw Blame
import uuid
from datetime import date
from decimal import Decimal

import bcrypt as _bcrypt
import pytest
from sqlalchemy.ext.asyncio import AsyncSession

from app.models.account import Account
from app.models.transaction import Transaction
from app.models.user import User
from app.schemas.group import GroupCreate, GroupMemberCreate
from app.schemas.group_settlement import (
    GroupSettlementCreate,
    GroupSettlementUpdate,
)
from app.services import group_service, settlement_service, workspace_service


async def _setup_group(session, user_id, workspace_id):
    group = await group_service.create_group(
        session, workspace_id, user_id, GroupCreate(name=f"S-{uuid.uuid4().hex[:6]}")
    )
    a = await group_service.create_member(
        session, group.id, workspace_id, GroupMemberCreate(name="Alice")
    )
    b = await group_service.create_member(
        session, group.id, workspace_id, GroupMemberCreate(name="Bob")
    )
    return group, a, b


async def _make_user_with_workspace(session, email):
    hashed = _bcrypt.hashpw(b"x", _bcrypt.gensalt()).decode()
    user = User(
        id=uuid.uuid4(),
        email=email,
        hashed_password=hashed,
        is_active=True,
        is_superuser=False,
        is_verified=True,
        preferences={"currency_display": "USD"},
    )
    session.add(user)
    await session.flush()
    workspace = await workspace_service.create_personal_workspace_for_user(
        session, user, commit=True
    )
    return user, workspace


async def _make_account(session, user_id, account_type="checking"):
    account = Account(
        id=uuid.uuid4(),
        user_id=user_id,
        name=f"Acc-{uuid.uuid4().hex[:4]}",
        type=account_type,
        balance=Decimal("0"),
        currency="USD",
    )
    session.add(account)
    await session.flush()
    return account


@pytest.mark.asyncio
async def test_create_settlement_happy_path(
    session: AsyncSession, test_user, test_workspace
):
    group, a, b = await _setup_group(session, test_user.id, test_workspace.id)
    s = await settlement_service.create_settlement(
        session,
        group.id,
        test_workspace.id,
        test_user.id,
        GroupSettlementCreate(
            from_member_id=a.id,
            to_member_id=b.id,
            amount=Decimal("12.50"),
            currency="USD",
            date=date.today(),
        ),
    )
    assert s is not None
    assert s.amount == Decimal("12.50")
    assert s.currency == "USD"


@pytest.mark.asyncio
async def test_settlement_members_must_belong_to_group(
    session: AsyncSession, test_user, test_workspace
):
    group, a, _b = await _setup_group(session, test_user.id, test_workspace.id)
    other_group, _x, y = await _setup_group(session, test_user.id, test_workspace.id)

    with pytest.raises(ValueError, match="must belong to the group"):
        await settlement_service.create_settlement(
            session,
            group.id,
            test_workspace.id,
            test_user.id,
            GroupSettlementCreate(
                from_member_id=a.id,
                to_member_id=y.id,  # belongs to other_group
                amount=Decimal("5.00"),
                currency="USD",
                date=date.today(),
            ),
        )


@pytest.mark.asyncio
async def test_settlement_from_to_must_differ_at_creation(
    session: AsyncSession, test_user, test_workspace
):
    group, a, _b = await _setup_group(session, test_user.id, test_workspace.id)
    # Pydantic-level validation rejects from == to before service runs.
    with pytest.raises(ValueError, match="must differ"):
        GroupSettlementCreate(
            from_member_id=a.id,
            to_member_id=a.id,
            amount=Decimal("5.00"),
            currency="USD",
            date=date.today(),
        )


@pytest.mark.asyncio
async def test_settlement_update_keeps_invariants(
    session: AsyncSession, test_user, test_workspace
):
    group, a, b = await _setup_group(session, test_user.id, test_workspace.id)
    s = await settlement_service.create_settlement(
        session,
        group.id,
        test_workspace.id,
        test_user.id,
        GroupSettlementCreate(
            from_member_id=a.id,
            to_member_id=b.id,
            amount=Decimal("10.00"),
            currency="USD",
            date=date.today(),
        ),
    )
    assert s is not None

    updated = await settlement_service.update_settlement(
        session,
        group.id,
        s.id,
        test_workspace.id,
        test_user.id,
        GroupSettlementUpdate(amount=Decimal("12.00"), notes="adjusted"),
    )

    assert updated is not None
    assert updated.amount == Decimal("12.00")
    assert updated.notes == "adjusted"

    # Updating to set both ends to the same member should fail.
    with pytest.raises(ValueError, match="must differ"):
        await settlement_service.update_settlement(
            session,
            group.id,
            s.id,
            test_workspace.id,
            test_user.id,
            GroupSettlementUpdate(to_member_id=a.id),
        )


@pytest.mark.asyncio
async def test_settlement_owner_isolation(
    session: AsyncSession, test_user, test_workspace
):
    group, a, b = await _setup_group(session, test_user.id, test_workspace.id)
    # A different workspace with a different user — neither can see the
    # group through their own scope.
    other_user, other_ws = await _make_user_with_workspace(
        session, "[email protected]"
    )
    result = await settlement_service.create_settlement(
        session,
        group.id,
        other_ws.id,
        other_user.id,
        GroupSettlementCreate(
            from_member_id=a.id,
            to_member_id=b.id,
            amount=Decimal("1.00"),
            currency="USD",
            date=date.today(),
        ),
    )
    assert result is None


# ---------------------------------------------------------------------------
# receiver_transaction_id (migration 045): when a settlement is recorded,
# the receiver-side credit transaction should be created (and pinned via
# `receiver_transaction_id`) iff the receiver maps to a real Securo user
# AND that user has a checking/savings account to receive into.
# ---------------------------------------------------------------------------


@pytest.mark.asyncio
async def test_receiver_credit_created_when_to_member_is_linked_with_account(
    session: AsyncSession, test_user, test_workspace
):
    receiver, _receiver_ws = await _make_user_with_workspace(
        session, "[email protected]"
    )
    receiver_account = await _make_account(session, receiver.id)
    payer_account = await _make_account(session, test_user.id)

    group = await group_service.create_group(
        session, test_workspace.id, test_user.id, GroupCreate(name="LinkedReceiver")
    )
    me = await group_service.create_member(
        session,
        group.id,
        test_workspace.id,
        GroupMemberCreate(name="Me", is_self=True),
    )
    bob = await group_service.create_member(
        session,
        group.id,
        test_workspace.id,
        GroupMemberCreate(name="Bob", linked_user_id=receiver.id),
    )

    assert me is not None
    assert bob is not None

    s = await settlement_service.create_settlement(
        session,
        group.id,
        test_workspace.id,
        test_user.id,
        GroupSettlementCreate(
            from_member_id=me.id,
            to_member_id=bob.id,
            amount=Decimal("50.00"),
            currency="USD",
            date=date.today(),
            account_id=payer_account.id,
        ),
    )
    assert s is not None
    assert s.receiver_transaction_id is not None

    receiver_tx = await session.get(Transaction, s.receiver_transaction_id)
    assert receiver_tx is not None
    assert receiver_tx.user_id == receiver.id
    assert receiver_tx.account_id == receiver_account.id
    assert receiver_tx.type == "credit"
    assert receiver_tx.amount == Decimal("50.00")
    assert receiver_tx.currency == "USD"
    assert receiver_tx.source == "settlement"


@pytest.mark.asyncio
async def test_receiver_credit_skipped_when_to_member_is_shadow(
    session: AsyncSession, test_user, test_workspace
):
    """Shadow member (no linked_user_id, not is_self) — there's no real
    user on the receiving side, so no credit transaction is created."""
    payer_account = await _make_account(session, test_user.id)
    group = await group_service.create_group(
        session, test_workspace.id, test_user.id, GroupCreate(name="ShadowReceiver")
    )
    me = await group_service.create_member(
        session,
        group.id,
        test_workspace.id,
        GroupMemberCreate(name="Me", is_self=True),
    )
    shadow = await group_service.create_member(
        session, group.id, test_workspace.id,         GroupMemberCreate(name="Shadow")
    )

    assert me is not None
    assert shadow is not None

    s = await settlement_service.create_settlement(
        session,
        group.id,
        test_workspace.id,
        test_user.id,
        GroupSettlementCreate(
            from_member_id=me.id,
            to_member_id=shadow.id,
            amount=Decimal("10.00"),
            currency="USD",
            date=date.today(),
            account_id=payer_account.id,
        ),
    )
    assert s is not None
    assert s.receiver_transaction_id is None


@pytest.mark.asyncio
async def test_receiver_credit_skipped_when_linked_user_has_no_cash_account(
    session: AsyncSession, test_user, test_workspace
):
    """Linked receiver, but their only account is a credit card (not
    checking/savings). The mirror credit can't be placed and is silently
    skipped — settlement is still recorded."""
    receiver, _receiver_ws = await _make_user_with_workspace(
        session, "[email protected]"
    )
    await _make_account(session, receiver.id, account_type="credit_card")
    payer_account = await _make_account(session, test_user.id)

    group = await group_service.create_group(
        session, test_workspace.id, test_user.id, GroupCreate(name="CCOnly")
    )
    me = await group_service.create_member(
        session,
        group.id,
        test_workspace.id,
        GroupMemberCreate(name="Me", is_self=True),
    )
    bob = await group_service.create_member(
        session,
        group.id,
        test_workspace.id,
        GroupMemberCreate(name="Bob", linked_user_id=receiver.id),
    )

    assert me is not None
    assert bob is not None

    s = await settlement_service.create_settlement(
        session,
        group.id,
        test_workspace.id,
        test_user.id,
        GroupSettlementCreate(
            from_member_id=me.id,
            to_member_id=bob.id,
            amount=Decimal("10.00"),
            currency="USD",
            date=date.today(),
            account_id=payer_account.id,
        ),
    )
    assert s is not None
    assert s.receiver_transaction_id is None


@pytest.mark.asyncio
async def test_receiver_credit_lands_on_owner_when_self_member_unlinked(
    session: AsyncSession, test_user, test_workspace
):
    """When the to_member is the owner's self-member with no
    linked_user_id, the service falls back to group.user_id — the
    credit lands on the owner's checking account."""
    owner_account = await _make_account(session, test_user.id)
    group = await group_service.create_group(
        session, test_workspace.id, test_user.id, GroupCreate(name="SelfFallback")
    )
    owner_self = await group_service.create_member(
        session,
        group.id,
        test_workspace.id,
        GroupMemberCreate(name="Me", is_self=True),
    )
    friend = await group_service.create_member(
        session, group.id, test_workspace.id,         GroupMemberCreate(name="Friend")
    )

    assert owner_self is not None
    assert friend is not None

    # Friend pays the owner back. Caller is the owner (allowed to record
    # on any from_member). No account_id — friend is a shadow, no real
    # account to debit. Receiver fallback should still kick in.
    s = await settlement_service.create_settlement(
        session,
        group.id,
        test_workspace.id,
        test_user.id,
        GroupSettlementCreate(
            from_member_id=friend.id,
            to_member_id=owner_self.id,
            amount=Decimal("20.00"),
            currency="USD",
            date=date.today(),
        ),
    )
    assert s is not None
    assert s.receiver_transaction_id is not None

    receiver_tx = await session.get(Transaction, s.receiver_transaction_id)
    assert receiver_tx is not None
    assert receiver_tx.user_id == test_user.id
    assert receiver_tx.account_id == owner_account.id
    assert receiver_tx.type == "credit"
    assert receiver_tx.amount == Decimal("20.00")