Skip to content

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

9.3 KB
Raw Blame
"""Coverage-focused tests for asset_group_service.

Exercises the rollup math (incl. value-history fallback and FX conversion),
get/update/delete paths, position assignment, and the connection-sync
helpers (`ensure_group_for_connection`, `_unique_default_name`).
"""
import uuid
from datetime import date, datetime, timezone
from decimal import Decimal

import pytest
from sqlalchemy.ext.asyncio import AsyncSession

from app.models.asset import Asset
from app.models.asset_group import AssetGroup
from app.models.asset_value import AssetValue
from app.models.bank_connection import BankConnection
from app.schemas.asset_group import AssetGroupCreate, AssetGroupUpdate
from app.services import asset_group_service as svc


async def _add_asset(session, user_id, workspace_id, group_id, *, currency="BRL",
                     purchase_price=None, value_amount=None, is_archived=False,
                     sell_date=None):
    asset = Asset(
        id=uuid.uuid4(),
        user_id=user_id,
        workspace_id=workspace_id,
        name=f"Asset-{uuid.uuid4().hex[:5]}",
        type="investment",
        currency=currency,
        group_id=group_id,
        purchase_price=purchase_price,
        is_archived=is_archived,
        sell_date=sell_date,
    )
    session.add(asset)
    await session.flush()
    if value_amount is not None:
        session.add(AssetValue(
            id=uuid.uuid4(),
            asset_id=asset.id,
            workspace_id=workspace_id,
            amount=value_amount,
            date=date.today(),
            source="manual",
        ))
        await session.flush()
    return asset


@pytest.mark.asyncio
async def test_create_group_assigns_next_position(session: AsyncSession, test_user, test_workspace):
    g1 = await svc.create_group(
        session, test_workspace.id, test_user.id, AssetGroupCreate(name="W1")
    )
    g2 = await svc.create_group(
        session, test_workspace.id, test_user.id, AssetGroupCreate(name="W2")
    )
    # position defaulted to 0 -> _next_position appends.
    assert g2.position == g1.position + 1
    assert g1.source == "manual"


@pytest.mark.asyncio
async def test_create_group_honors_explicit_position(session: AsyncSession, test_user, test_workspace):
    g = await svc.create_group(
        session, test_workspace.id, test_user.id,
        AssetGroupCreate(name="Pinned", position=7),
    )
    assert g.position == 7


@pytest.mark.asyncio
async def test_get_groups_rolls_up_values_and_fallback(session: AsyncSession, test_user, test_workspace):
    g = await svc.create_group(
        session, test_workspace.id, test_user.id, AssetGroupCreate(name="Rollup")
    )
    # One asset with a value-history row (primary currency BRL).
    await _add_asset(session, test_user.id, test_workspace.id, g.id,
                     currency="BRL", value_amount=Decimal("100"))
    # One asset with NO value history -> falls back to purchase_price.
    await _add_asset(session, test_user.id, test_workspace.id, g.id,
                     currency="BRL", purchase_price=Decimal("50"))
    # Archived asset -> excluded.
    await _add_asset(session, test_user.id, test_workspace.id, g.id,
                     currency="BRL", value_amount=Decimal("999"), is_archived=True)
    # Sold asset -> excluded.
    await _add_asset(session, test_user.id, test_workspace.id, g.id,
                     currency="BRL", value_amount=Decimal("999"), sell_date=date.today())
    # Asset with neither value nor purchase_price -> skipped silently.
    await _add_asset(session, test_user.id, test_workspace.id, g.id, currency="BRL")
    await session.commit()

    groups = await svc.get_groups(session, test_workspace.id, test_user.id)
    by_name = {x.name: x for x in groups}
    assert "Rollup" in by_name
    read = by_name["Rollup"]
    # asset_count counts non-archived, non-sold assets (3: two valued + one
    # with no value/price that is still counted). Sold/archived excluded.
    assert read.asset_count == 3
    assert read.current_value == 150.0
    # Primary currency is BRL (test_user pref) -> matches without conversion.
    assert read.current_value_primary == 150.0


@pytest.mark.asyncio
async def test_get_groups_converts_foreign_currency(session: AsyncSession, test_user, test_workspace, monkeypatch):
    g = await svc.create_group(
        session, test_workspace.id, test_user.id, AssetGroupCreate(name="FX")
    )
    await _add_asset(session, test_user.id, test_workspace.id, g.id,
                     currency="USD", value_amount=Decimal("10"))
    await session.commit()

    async def _fake_convert_or_none(session, amount, frm, to, *args, **kwargs):
        return Decimal(amount) * Decimal("5"), Decimal("5")

    monkeypatch.setattr(svc, "convert_or_none", _fake_convert_or_none)

    groups = await svc.get_groups(session, test_workspace.id, test_user.id)
    read = {x.name: x for x in groups}["FX"]
    assert read.current_value == 10.0
    assert read.current_value_primary == 50.0


@pytest.mark.asyncio
async def test_get_groups_empty_returns_empty(session: AsyncSession, test_user, test_workspace):
    assert await svc.get_groups(session, test_workspace.id, test_user.id) == []


@pytest.mark.asyncio
async def test_get_groups_includes_institution_name(session: AsyncSession, test_user, test_workspace):
    conn = BankConnection(
        id=uuid.uuid4(),
        user_id=test_user.id,
        provider="pluggy",
        external_id="item-x",
        institution_name="Nubank",
        credentials={"t": "x"},
        status="active",
        created_at=datetime.now(timezone.utc),
    )
    session.add(conn)
    await session.flush()
    g = AssetGroup(
        id=uuid.uuid4(),
        user_id=test_user.id,
        workspace_id=test_workspace.id,
        name="Synced",
        source="pluggy",
        connection_id=conn.id,
    )
    session.add(g)
    await session.flush()
    await _add_asset(session, test_user.id, test_workspace.id, g.id,
                     currency="BRL", value_amount=Decimal("1"))
    await session.commit()

    groups = await svc.get_groups(session, test_workspace.id, test_user.id)
    read = {x.name: x for x in groups}["Synced"]
    assert read.institution_name == "Nubank"


@pytest.mark.asyncio
async def test_get_group_found_and_not_found(session: AsyncSession, test_user, test_workspace):
    g = await svc.create_group(
        session, test_workspace.id, test_user.id, AssetGroupCreate(name="One")
    )
    found = await svc.get_group(session, g.id, test_workspace.id, test_user.id)
    assert found is not None
    assert found.name == "One"

    missing = await svc.get_group(session, uuid.uuid4(), test_workspace.id, test_user.id)
    assert missing is None


@pytest.mark.asyncio
async def test_update_group(session: AsyncSession, test_user, test_workspace):
    g = await svc.create_group(
        session, test_workspace.id, test_user.id, AssetGroupCreate(name="Old")
    )
    updated = await svc.update_group(
        session, g.id, test_workspace.id, test_user.id,
        AssetGroupUpdate(name="New", color="#000000"),
    )
    assert updated is not None
    assert updated.name == "New"
    assert updated.color == "#000000"

    none = await svc.update_group(
        session, uuid.uuid4(), test_workspace.id, test_user.id,
        AssetGroupUpdate(name="X"),
    )
    assert none is None


@pytest.mark.asyncio
async def test_delete_group(session: AsyncSession, test_user, test_workspace):
    g = await svc.create_group(
        session, test_workspace.id, test_user.id, AssetGroupCreate(name="Doomed")
    )
    assert await svc.delete_group(session, g.id, test_workspace.id) is True
    assert await svc.delete_group(session, g.id, test_workspace.id) is False


@pytest.mark.asyncio
async def test_ensure_group_for_connection_creates_then_relinks(session: AsyncSession, test_user):
    conn_id = uuid.uuid4()
    g = await svc.ensure_group_for_connection(
        session, test_user.id, conn_id, "pluggy", "ext-1", "MeuPluggy"
    )
    assert g.name == "MeuPluggy"
    assert g.connection_id == conn_id
    assert g.source == "pluggy"

    # Same external_id, new connection -> relink, keep name.
    new_conn = uuid.uuid4()
    g2 = await svc.ensure_group_for_connection(
        session, test_user.id, new_conn, "pluggy", "ext-1", "Renamed"
    )
    assert g2.id == g.id
    assert g2.connection_id == new_conn
    assert g2.name == "MeuPluggy"


@pytest.mark.asyncio
async def test_ensure_group_for_connection_matches_by_connection_id(session: AsyncSession, test_user):
    conn_id = uuid.uuid4()
    g = await svc.ensure_group_for_connection(
        session, test_user.id, conn_id, "pluggy", None, "NoExtId"
    )
    g2 = await svc.ensure_group_for_connection(
        session, test_user.id, conn_id, "pluggy", None, "Other"
    )
    assert g2.id == g.id


@pytest.mark.asyncio
async def test_ensure_group_for_connection_disambiguates_name(session: AsyncSession, test_user):
    # Two distinct external ids, same default name -> " 2" suffix.
    g1 = await svc.ensure_group_for_connection(
        session, test_user.id, uuid.uuid4(), "pluggy", "ext-a", "MeuPluggy"
    )
    g2 = await svc.ensure_group_for_connection(
        session, test_user.id, uuid.uuid4(), "pluggy", "ext-b", "MeuPluggy"
    )
    g3 = await svc.ensure_group_for_connection(
        session, test_user.id, uuid.uuid4(), "pluggy", "ext-c", "MeuPluggy"
    )
    assert g1.name == "MeuPluggy"
    assert g2.name == "MeuPluggy 2"
    assert g3.name == "MeuPluggy 3"