Open-source personal finance manager. Self-hosted, privacy-first.
"""Cover the Asset lifecycle through `_sync_holdings`.
The sync contract is a bit subtle: provider data drives creation *and*
closure of Assets, but user-set fields are load-bearing — manual sell_date
is never overwritten, while provider closures reopen if the holding returns
ACTIVE; group_id is rewritten only between wallets the
sync itself owns (per-account re-attribution, issue #345); a wallet the
user chose is never touched (see test_connection_service.py for the
re-attribution matrix). These tests pin the rest: new/existing ×
active/withdrawn, same-day vs next-day re-syncs, historical seeding
idempotency, and sparse-field merging.
"""
from __future__ import annotations
import uuid
from datetime import date, datetime, timedelta, timezone
from decimal import Decimal
from typing import Optional
import pytest
import pytest_asyncio
from sqlalchemy import select
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.models.user import User
from app.providers import register_provider
from app.providers.base import (
AccountData,
BankProvider,
ConnectionData,
HoldingData,
TransactionData,
)
from app.services.connection_service import _sync_holdings
# ---------------------------------------------------------------------------
# Mock provider — deterministic replacement for Pluggy/Belvo in tests.
# ---------------------------------------------------------------------------
class _MockProvider(BankProvider):
"""BankProvider that returns a caller-supplied list of holdings.
We store the list on a class-level mutable slot so each test can
reconfigure the response without juggling singleton re-registration.
"""
_holdings: list[HoldingData] = []
_raise: Optional[Exception] = None
@property
def name(self) -> str:
return "mock"
async def get_oauth_url(
self, redirect_uri: str, state: str, flow_params=None
) -> str: # pragma: no cover
return "http://mock"
async def handle_oauth_callback(self, code: str) -> ConnectionData: # pragma: no cover
raise NotImplementedError
async def get_accounts(self, credentials: dict) -> list[AccountData]: # pragma: no cover
return []
async def get_transactions(
self, credentials: dict, account_external_id: str, since=None, payee_source: str = "auto"
) -> list[TransactionData]: # pragma: no cover
return []
async def refresh_credentials(self, credentials: dict) -> dict: # pragma: no cover
return credentials
async def get_holdings(self, credentials: dict) -> list[HoldingData]:
if _MockProvider._raise is not None:
raise _MockProvider._raise
return list(_MockProvider._holdings)
@pytest.fixture(autouse=True)
def _register_mock_provider():
"""Auto-register mock provider for every test in this module."""
register_provider("mock", _MockProvider)
_MockProvider._holdings = []
_MockProvider._raise = None
yield
# ---------------------------------------------------------------------------
# Fixtures specific to holdings sync.
# ---------------------------------------------------------------------------
@pytest_asyncio.fixture
async def mock_connection(session: AsyncSession, test_user: User) -> BankConnection:
conn = BankConnection(
id=uuid.uuid4(),
user_id=test_user.id,
provider="mock",
external_id="item-abc",
institution_name="Mock Bank",
credentials={"item_id": "item-abc"},
status="active",
created_at=datetime.now(timezone.utc),
)
session.add(conn)
await session.commit()
await session.refresh(conn)
return conn
def _holding(
*,
external_id: str = "h-1",
name: str = "CDB NU",
current_value: Decimal = Decimal("1000.00"),
purchase_price: Optional[Decimal] = Decimal("900.00"),
purchase_date: Optional[date] = None,
quantity: Optional[Decimal] = Decimal("1"),
is_withdrawn: bool = False,
metadata: Optional[dict] = None,
) -> HoldingData:
return HoldingData(
external_id=external_id,
name=name,
currency="BRL",
current_value=current_value,
quantity=quantity,
purchase_price=purchase_price,
purchase_date=purchase_date,
is_withdrawn=is_withdrawn,
metadata=(
metadata
if metadata is not None
else {"status": "TOTAL_WITHDRAWAL" if is_withdrawn else "ACTIVE"}
),
)
async def _assets_for(session: AsyncSession, user: User) -> list[Asset]:
rows = await session.execute(select(Asset).where(Asset.user_id == user.id))
return list(rows.scalars().all())
async def _values_for(session: AsyncSession, asset_id) -> list[AssetValue]:
rows = await session.execute(
select(AssetValue).where(AssetValue.asset_id == asset_id).order_by(AssetValue.date)
)
return list(rows.scalars().all())
# ---------------------------------------------------------------------------
# Tests
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_new_active_holding_creates_asset_wallet_and_today_value(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""Happy path: one fresh ACTIVE holding → Asset + wallet + today's value."""
today = date.today()
_MockProvider._holdings = [
_holding(current_value=Decimal("1234.56"), purchase_date=today - timedelta(days=10)),
]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
assets = await _assets_for(session, test_user)
assert len(assets) == 1
asset = assets[0]
assert asset.external_id == "h-1"
assert asset.source == "mock"
assert asset.connection_id == mock_connection.id
assert asset.sell_date is None
assert asset.is_archived is False
# Wallet auto-created and the asset attached.
assert asset.group_id is not None
wallet = await session.get(AssetGroup, asset.group_id)
assert wallet is not None
assert wallet.connection_id == mock_connection.id
values = await _values_for(session, asset.id)
# Historical seed at purchase_date + today's snapshot.
dates = [v.date for v in values]
assert today - timedelta(days=10) in dates
assert today in dates
@pytest.mark.asyncio
async def test_new_withdrawn_holding_is_skipped_entirely(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""A holding that's already TOTAL_WITHDRAWAL on first sight should not
create a zero-balance Asset — there's no meaningful history to show."""
_MockProvider._holdings = [
_holding(external_id="dead-1", current_value=Decimal("0"), is_withdrawn=True),
]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
assert await _assets_for(session, test_user) == []
@pytest.mark.asyncio
async def test_withdrawn_existing_asset_gets_sell_date(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""Position was ACTIVE on a prior sync, now TOTAL_WITHDRAWAL. We set
sell_date to today, leave historical AssetValues intact, and do not
append a fresh zero value."""
today = date.today()
# First sync: active.
_MockProvider._holdings = [_holding(external_id="h-1", current_value=Decimal("500"))]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
[asset] = await _assets_for(session, test_user)
values_before = await _values_for(session, asset.id)
assert asset.sell_date is None
assert len(values_before) >= 1
# Second sync: withdrawn.
_MockProvider._holdings = [
_holding(external_id="h-1", current_value=Decimal("0"), is_withdrawn=True)
]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
await session.refresh(asset)
assert asset.sell_date == today
assert asset.external_metadata is not None
assert asset.external_metadata["status"] == "TOTAL_WITHDRAWAL"
values_after = await _values_for(session, asset.id)
# Historical values preserved; no zero appended.
assert len(values_after) == len(values_before)
assert all(v.amount != Decimal("0") for v in values_after)
@pytest.mark.asyncio
async def test_withdrawn_existing_does_not_overwrite_user_sell_date(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""If the user manually marked sell_date (e.g. they know the exact
redemption date), a later provider-reported withdrawal must not clobber it."""
user_sell_date = date.today() - timedelta(days=30)
asset = Asset(
id=uuid.uuid4(),
user_id=test_user.id,
connection_id=mock_connection.id,
source="mock",
external_id="h-1",
name="CDB NU",
type="investment",
currency="BRL",
sell_date=user_sell_date,
)
session.add(asset)
await session.commit()
_MockProvider._holdings = [
_holding(external_id="h-1", current_value=Decimal("0"), is_withdrawn=True)
]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
await session.refresh(asset)
assert asset.sell_date == user_sell_date
@pytest.mark.asyncio
async def test_user_sold_active_on_provider_stops_value_updates(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""User marked the asset sold but the provider still reports it active.
Respect the user: no new AssetValues should be appended, so dashboards
don't keep moving for a position the user considers closed."""
user_sell_date = date.today() - timedelta(days=5)
asset = Asset(
id=uuid.uuid4(),
user_id=test_user.id,
connection_id=mock_connection.id,
source="mock",
external_id="h-1",
name="CDB NU",
type="investment",
currency="BRL",
sell_date=user_sell_date,
)
session.add(asset)
await session.commit()
_MockProvider._holdings = [_holding(external_id="h-1", current_value=Decimal("999.99"))]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
await session.refresh(asset)
assert asset.sell_date == user_sell_date # untouched
values = await _values_for(session, asset.id)
assert values == [] # no new values recorded
@pytest.mark.asyncio
async def test_provider_withdrawn_holding_reopens_when_active_again(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""A transient TOTAL_WITHDRAWAL must not leave an ACTIVE holding sold."""
_MockProvider._holdings = [
_holding(external_id="h-1", current_value=Decimal("500")),
]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
[asset] = await _assets_for(session, test_user)
_MockProvider._holdings = [
_holding(external_id="h-1", current_value=Decimal("0"), is_withdrawn=True),
]
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
await session.refresh(asset)
assert asset.sell_date == date.today()
assert asset.external_metadata is not None
assert asset.external_metadata["status"] == "TOTAL_WITHDRAWAL"
_MockProvider._holdings = [
_holding(external_id="h-1", current_value=Decimal("525")),
]
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
await session.refresh(asset)
assert asset.sell_date is None
assert asset.external_metadata is not None
assert asset.external_metadata["status"] == "ACTIVE"
values = await _values_for(session, asset.id)
assert any(v.date == date.today() and v.amount == Decimal("525") for v in values)
@pytest.mark.asyncio
async def test_withdrawal_status_with_positive_balance_keeps_asset_active(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""Issue #819: the provider can deliver a contradictory payload whose
raw status says TOTAL_WITHDRAWAL while the position still reports a
positive balance and quantity. The payload goes through the real
provider mapping and then the sync, which must keep the asset active
and keep recording today's value, with the raw status preserved in
metadata."""
from app.providers.pluggy import _build_holding_data
def _raw(status: str, balance: float) -> dict:
return {
"id": "h-1",
"name": "Fixed income fund",
"type": "FIXED_INCOME",
"currencyCode": "BRL",
"status": status,
"balance": balance,
"quantity": 10,
"value": balance / 10,
}
_MockProvider._holdings = [_build_holding_data(_raw("ACTIVE", 500))]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
[asset] = await _assets_for(session, test_user)
assert asset.sell_date is None
_MockProvider._holdings = [_build_holding_data(_raw("TOTAL_WITHDRAWAL", 510))]
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
await session.refresh(asset)
assert asset.sell_date is None
assert asset.is_archived is False
assert asset.external_metadata is not None
assert asset.external_metadata["status"] == "TOTAL_WITHDRAWAL"
values = await _values_for(session, asset.id)
assert any(v.date == date.today() and v.amount == Decimal("510") for v in values)
@pytest.mark.asyncio
async def test_active_holding_preserves_sell_date_edited_after_provider_withdrawal(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""A user correction after withdrawal must survive provider reactivation."""
_MockProvider._holdings = [
_holding(external_id="h-1", current_value=Decimal("500")),
]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
[asset] = await _assets_for(session, test_user)
_MockProvider._holdings = [
_holding(external_id="h-1", current_value=Decimal("0"), is_withdrawn=True),
]
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
corrected_sell_date = date.today() - timedelta(days=14)
asset.sell_date = corrected_sell_date
await session.commit()
_MockProvider._holdings = [
_holding(external_id="h-1", current_value=Decimal("525")),
]
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
await session.refresh(asset)
assert asset.sell_date == corrected_sell_date
assert asset.external_metadata is not None
assert asset.external_metadata["status"] == "ACTIVE"
@pytest.mark.asyncio
async def test_same_day_resync_updates_asset_value_in_place(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""Running sync twice in one day must not duplicate the day's AssetValue —
the second pass updates the amount in the existing row."""
_MockProvider._holdings = [_holding(external_id="h-1", current_value=Decimal("100"))]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
[asset] = await _assets_for(session, test_user)
_MockProvider._holdings = [_holding(external_id="h-1", current_value=Decimal("110"))]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
values = await _values_for(session, asset.id)
today = date.today()
today_rows = [v for v in values if v.date == today]
assert len(today_rows) == 1
assert today_rows[0].amount == Decimal("110")
@pytest.mark.asyncio
async def test_sparse_fields_are_preserved_on_later_sync(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""Pluggy returns purchase_price/purchase_date/units on some syncs and
null on others. Earlier non-null values must not be clobbered by later
nulls — otherwise the user loses provenance data permanently."""
_MockProvider._holdings = [
_holding(
external_id="h-1",
current_value=Decimal("500"),
purchase_price=Decimal("450"),
quantity=Decimal("10"),
purchase_date=date.today() - timedelta(days=100),
)
]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
[asset] = await _assets_for(session, test_user)
assert asset.purchase_price == Decimal("450")
assert asset.units == Decimal("10")
_MockProvider._holdings = [
_holding(
external_id="h-1",
current_value=Decimal("520"),
purchase_price=None,
quantity=None,
purchase_date=None,
)
]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
await session.refresh(asset)
assert asset.purchase_price == Decimal("450")
assert asset.units == Decimal("10")
@pytest.mark.asyncio
async def test_historical_seed_is_idempotent(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""Historical seed at purchase_date should be inserted exactly once —
running sync 3× still leaves a single row at that date."""
purchase = date.today() - timedelta(days=60)
_MockProvider._holdings = [
_holding(
external_id="h-1",
current_value=Decimal("1000"),
purchase_price=Decimal("900"),
purchase_date=purchase,
)
]
assert mock_connection.credentials is not None
for _ in range(3):
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
[asset] = await _assets_for(session, test_user)
purchase_rows = [v for v in await _values_for(session, asset.id) if v.date == purchase]
assert len(purchase_rows) == 1
assert purchase_rows[0].amount == Decimal("900")
@pytest.mark.asyncio
async def test_historical_seed_respects_prior_manual_value(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""If a manual AssetValue already exists at purchase_date, the seed must
not overwrite it. Users' numbers always win over provider defaults."""
purchase = date.today() - timedelta(days=60)
asset = Asset(
id=uuid.uuid4(),
user_id=test_user.id,
connection_id=mock_connection.id,
source="mock",
external_id="h-1",
name="CDB NU",
type="investment",
currency="BRL",
)
session.add(asset)
session.add(
AssetValue(
asset_id=asset.id,
amount=Decimal("777"),
date=purchase,
source="manual",
)
)
await session.commit()
_MockProvider._holdings = [
_holding(
external_id="h-1",
current_value=Decimal("1000"),
purchase_price=Decimal("900"),
purchase_date=purchase,
)
]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
rows = [v for v in await _values_for(session, asset.id) if v.date == purchase]
assert len(rows) == 1
assert rows[0].amount == Decimal("777")
assert rows[0].source == "manual"
@pytest.mark.asyncio
async def test_disappeared_holding_gets_archived(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""If a previously-synced holding is no longer in the provider response
at all (e.g. broker removed it), archive the Asset so it stops cluttering
the UI — but don't delete it, history matters."""
_MockProvider._holdings = [
_holding(external_id="h-1", current_value=Decimal("500")),
_holding(external_id="h-2", current_value=Decimal("200")),
]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
# Only h-1 comes back on the next sync. h-2 must be archived.
_MockProvider._holdings = [_holding(external_id="h-1", current_value=Decimal("510"))]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
assets = {a.external_id: a for a in await _assets_for(session, test_user)}
assert assets["h-1"].is_archived is False
assert assets["h-2"].is_archived is True
@pytest.mark.asyncio
async def test_returned_holding_is_unarchived_after_reconnect(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""A holding archived on unlink should become active again when reconnected."""
_MockProvider._holdings = [_holding(external_id="h-1", current_value=Decimal("500"))]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
# Next sync does not include h-1 -> archived.
_MockProvider._holdings = []
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
assets = {a.external_id: a for a in await _assets_for(session, test_user)}
assert assets["h-1"].is_archived is True
# Simulate unlink/reconnect: old connection disappears and a new one syncs.
await session.delete(mock_connection)
await session.commit()
reconnected = BankConnection(
id=uuid.uuid4(),
user_id=test_user.id,
provider="mock",
external_id="item-reconnected",
institution_name="Mock Bank",
credentials={"item_id": "item-reconnected"},
status="active",
created_at=datetime.now(timezone.utc),
)
session.add(reconnected)
await session.commit()
# Later sync includes h-1 again -> should unarchive.
_MockProvider._holdings = [_holding(external_id="h-1", current_value=Decimal("525"))]
assert reconnected.credentials is not None
await _sync_holdings(session, test_user.id, reconnected, reconnected.credentials)
await session.commit()
assets = {a.external_id: a for a in await _assets_for(session, test_user)}
assert assets["h-1"].is_archived is False
@pytest.mark.asyncio
async def test_user_archived_holding_stays_archived_on_same_connection_sync(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""Sync must not override a user archive decision on the same connection."""
_MockProvider._holdings = [_holding(external_id="h-1", current_value=Decimal("500"))]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
assets = {a.external_id: a for a in await _assets_for(session, test_user)}
assets["h-1"].is_archived = True
await session.commit()
_MockProvider._holdings = [_holding(external_id="h-1", current_value=Decimal("510"))]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
assets = {a.external_id: a for a in await _assets_for(session, test_user)}
assert assets["h-1"].is_archived is True
@pytest.mark.asyncio
async def test_user_moved_asset_to_custom_wallet_not_overridden(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""If the user moves a synced asset to a custom wallet, later syncs must
not drag it back to the provider's default wallet."""
_MockProvider._holdings = [_holding(external_id="h-1", current_value=Decimal("500"))]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
[asset] = await _assets_for(session, test_user)
default_wallet_id = asset.group_id
# Simulate user moving to a custom wallet.
custom_wallet = AssetGroup(
id=uuid.uuid4(),
user_id=test_user.id,
name="US Stocks",
icon="briefcase",
color="#000",
position=5,
source="manual",
)
session.add(custom_wallet)
await session.commit()
asset.group_id = custom_wallet.id
await session.commit()
_MockProvider._holdings = [_holding(external_id="h-1", current_value=Decimal("520"))]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
await session.refresh(asset)
assert asset.group_id == custom_wallet.id
assert asset.group_id != default_wallet_id
@pytest.mark.asyncio
async def test_provider_error_is_swallowed_without_side_effects(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""/investments errors must not crash the account/transaction sync that
just succeeded — silent failure here is intentional."""
_MockProvider._raise = RuntimeError("provider 500")
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
# No assets, no exception.
assert await _assets_for(session, test_user) == []
@pytest.mark.asyncio
async def test_next_day_sync_appends_new_asset_value(
session: AsyncSession, test_user: User, mock_connection: BankConnection
):
"""Value history accumulates: a pre-existing yesterday row must remain
alongside today's new row."""
yesterday = date.today() - timedelta(days=1)
asset = Asset(
id=uuid.uuid4(),
user_id=test_user.id,
connection_id=mock_connection.id,
source="mock",
external_id="h-1",
name="CDB NU",
type="investment",
currency="BRL",
)
session.add(asset)
session.add(AssetValue(asset_id=asset.id, amount=Decimal("100"), date=yesterday, source="sync"))
await session.commit()
_MockProvider._holdings = [_holding(external_id="h-1", current_value=Decimal("105"))]
assert mock_connection.credentials is not None
await _sync_holdings(session, test_user.id, mock_connection, mock_connection.credentials)
await session.commit()
rows = await _values_for(session, asset.id)
assert len(rows) == 2
assert rows[0].date == yesterday and rows[0].amount == Decimal("100")
assert rows[1].date == date.today() and rows[1].amount == Decimal("105")