Open-source personal finance manager. Self-hosted, privacy-first.
import uuid
from datetime import date, timedelta
from decimal import Decimal
import pytest
from sqlalchemy.ext.asyncio import AsyncSession
from app.core.app_clock import app_today
from app.models.account import Account
from app.models.category import Category
from app.models.recurring_transaction import RecurringTransaction
from app.models.transaction import Transaction
from app.models.bank_connection import BankConnection
from app.services.dashboard_service import (
_balance_at,
_baseline_from_deltas,
_get_recurring_projections,
_month_range,
_get_open_accounts,
_account_balance_at,
_total_balance_by_currency,
get_balance_history,
get_balance_history_months,
get_monthly_trend,
get_summary,
get_spending_by_category,
get_projected_transactions,
)
from app.services.transaction_service import get_transactions
# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------
async def _make_account(
session: AsyncSession, user_id: uuid.UUID,
name: str = "Dash Test", acc_type: str = "checking",
balance: str = "0.00", currency: str = "BRL",
connection_id: uuid.UUID | None = None,
is_closed: bool = False,
) -> Account:
account = Account(
id=uuid.uuid4(), user_id=user_id, name=name,
type=acc_type, balance=Decimal(balance), currency=currency,
connection_id=connection_id, is_closed=is_closed,
)
session.add(account)
await session.commit()
await session.refresh(account)
return account
async def _add_txn(
session: AsyncSession, user_id: uuid.UUID, account_id: uuid.UUID,
amount: float, txn_type: str, txn_date: date,
source: str = "manual", transfer_pair_id: uuid.UUID | None = None,
category_id: uuid.UUID | None = None, status: str = "posted",
) -> Transaction:
from datetime import datetime, timezone
txn = Transaction(
id=uuid.uuid4(), user_id=user_id, account_id=account_id,
description=f"Test {txn_type} {amount}", amount=Decimal(str(amount)),
date=txn_date, type=txn_type, source=source, currency="BRL",
transfer_pair_id=transfer_pair_id, category_id=category_id,
status=status,
created_at=datetime.now(timezone.utc),
)
session.add(txn)
await session.commit()
await session.refresh(txn)
return txn
async def _make_category(
session: AsyncSession, user_id: uuid.UUID, name: str,
icon: str = "tag", color: str = "#000",
) -> Category:
cat = Category(
id=uuid.uuid4(), user_id=user_id, name=name,
icon=icon, color=color, is_system=False,
)
session.add(cat)
await session.commit()
await session.refresh(cat)
return cat
# ---------------------------------------------------------------------------
# _month_range (pure function)
# ---------------------------------------------------------------------------
def test_month_range_normal():
start, end = _month_range(date(2025, 6, 15))
assert start == date(2025, 6, 1)
assert end == date(2025, 7, 1)
def test_month_range_december():
start, end = _month_range(date(2025, 12, 20))
assert start == date(2025, 12, 1)
assert end == date(2026, 1, 1)
def test_month_range_january():
start, end = _month_range(date(2026, 1, 1))
assert start == date(2026, 1, 1)
assert end == date(2026, 2, 1)
# ---------------------------------------------------------------------------
# _get_open_accounts
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_get_open_accounts(session: AsyncSession, test_user, test_workspace):
"""Returns only non-closed accounts."""
open_acc = await _make_account(session, test_user.id, "Open")
closed_acc = await _make_account(session, test_user.id, "Closed", is_closed=True)
accounts = await _get_open_accounts(session, test_workspace.id)
ids = [a.id for a in accounts]
assert open_acc.id in ids
assert closed_acc.id not in ids
# ---------------------------------------------------------------------------
# _account_balance_at (dashboard version — supports bank-connected)
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_account_balance_at_manual(session: AsyncSession, test_user):
"""Manual account balance is sum of transactions up to cutoff."""
account = await _make_account(session, test_user.id, "Manual Bal")
today = date.today()
await _add_txn(session, test_user.id, account.id, 1000, "credit", today - timedelta(days=10), source="opening_balance")
await _add_txn(session, test_user.id, account.id, 200, "debit", today - timedelta(days=5))
await _add_txn(session, test_user.id, account.id, 300, "debit", today)
# Balance at 3 days ago should be 1000 - 200 = 800 (excludes today's 300 debit)
bal = await _account_balance_at(session, account, today - timedelta(days=3))
assert bal == pytest.approx(800.0)
@pytest.mark.asyncio
async def test_account_balance_at_manual_opening_fallback(session: AsyncSession, test_user):
"""Opening balance dated after cutoff is not carried back — it appears as a delta on its actual date."""
account = await _make_account(session, test_user.id, "Fallback Bal")
today = date.today()
# Opening balance dated today, cutoff is yesterday
await _add_txn(session, test_user.id, account.id, 5000, "credit", today, source="opening_balance")
# Balance at yesterday is 0 — the opening balance hasn't happened yet
bal = await _account_balance_at(session, account, today - timedelta(days=1))
assert bal == pytest.approx(0.0)
# Balance at today includes the opening balance
bal_today = await _account_balance_at(session, account, today)
assert bal_today == pytest.approx(5000.0)
@pytest.mark.asyncio
async def test_account_balance_at_bank_connected(session: AsyncSession, test_user, test_connection):
"""Bank-connected account backtracks from stored balance."""
account = await _make_account(
session, test_user.id, "Connected Bal", balance="5000.00",
connection_id=test_connection.id,
)
today = date.today()
# Add transactions after cutoff
await _add_txn(session, test_user.id, account.id, 300, "credit", today)
# Balance at yesterday = 5000 - 300 = 4700
bal = await _account_balance_at(session, account, today - timedelta(days=1))
assert bal == pytest.approx(4700.0)
@pytest.mark.asyncio
async def test_account_balance_at_manual_excludes_ignored_categories(
session: AsyncSession, test_user
):
account = await _make_account(session, test_user.id, "Manual ignored")
ignored = Category(
id=uuid.uuid4(),
user_id=test_user.id,
name="Ignored",
is_ignored=True,
)
ordinary = Category(
id=uuid.uuid4(),
user_id=test_user.id,
name="Ordinary",
is_ignored=False,
)
session.add_all([ignored, ordinary])
await session.commit()
await _add_txn(
session, test_user.id, account.id, 1000, "credit",
date(2026, 7, 1), source="opening_balance",
)
await _add_txn(
session, test_user.id, account.id, 100, "debit",
date(2026, 8, 3), category_id=ignored.id,
)
await _add_txn(
session, test_user.id, account.id, 40, "debit",
date(2026, 8, 4), category_id=ordinary.id,
)
await _add_txn(
session, test_user.id, account.id, 10, "debit",
date(2026, 8, 5),
)
balance = await _account_balance_at(session, account, date(2026, 9, 1))
assert balance == pytest.approx(950.0)
@pytest.mark.asyncio
async def test_account_balance_at_connected_excludes_ignored_categories(
session: AsyncSession, test_user, test_connection
):
account = await _make_account(
session,
test_user.id,
"Connected ignored",
balance="850.00",
connection_id=test_connection.id,
)
ignored = Category(
id=uuid.uuid4(),
user_id=test_user.id,
name="Ignored",
is_ignored=True,
)
ordinary = Category(
id=uuid.uuid4(),
user_id=test_user.id,
name="Ordinary",
is_ignored=False,
)
session.add_all([ignored, ordinary])
await session.commit()
await _add_txn(
session, test_user.id, account.id, 100, "debit",
date(2026, 8, 2), category_id=ignored.id,
)
individually_ignored = await _add_txn(
session, test_user.id, account.id, 50, "debit",
date(2026, 8, 3),
)
individually_ignored.is_ignored = True
await _add_txn(
session, test_user.id, account.id, 200, "credit",
date(2026, 8, 4),
)
await _add_txn(
session, test_user.id, account.id, 50, "debit",
date(2026, 8, 5), category_id=ordinary.id,
)
await session.commit()
balance = await _account_balance_at(session, account, date(2026, 8, 1))
assert balance == pytest.approx(700.0)
@pytest.mark.asyncio
async def test_account_balance_at_credit_card_connected(session: AsyncSession, test_user, test_connection):
"""Bank-connected credit_card negates balance."""
account = await _make_account(
session, test_user.id, "CC Bal", acc_type="credit_card", balance="2000.00",
connection_id=test_connection.id,
)
bal = await _account_balance_at(session, account, date.today())
# Credit card: current_bal = -2000
assert bal == pytest.approx(-2000.0)
# ---------------------------------------------------------------------------
# _total_balance_by_currency
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_total_balance_by_currency(session: AsyncSession, test_user, test_workspace):
"""Total balance groups by currency."""
brl_acc = await _make_account(session, test_user.id, "BRL", currency="BRL")
usd_acc = await _make_account(session, test_user.id, "USD", currency="USD")
today = date.today()
await _add_txn(session, test_user.id, brl_acc.id, 1000, "credit", today, source="opening_balance")
await _add_txn(session, test_user.id, usd_acc.id, 500, "credit", today, source="opening_balance")
totals = await _total_balance_by_currency(session, test_workspace.id, today)
assert totals.get("BRL", 0) == pytest.approx(1000.0)
assert totals.get("USD", 0) == pytest.approx(500.0)
@pytest.mark.asyncio
async def test_total_balance_counts_shared_credit_balance_once(
session, test_user, test_workspace, test_connection,
):
group = "pluggy:connection:shared-credit"
first = await _make_account(
session, test_user.id, "Shared Visa", acc_type="credit_card", balance="300.00",
connection_id=test_connection.id,
)
second = await _make_account(
session, test_user.id, "Shared Mastercard", acc_type="credit_card", balance="300.00",
connection_id=test_connection.id,
)
first.workspace_id = test_workspace.id
second.workspace_id = test_workspace.id
first.shared_balance_group = group
second.shared_balance_group = group
await session.commit()
totals = await _total_balance_by_currency(session, test_workspace.id, date.today())
assert totals["BRL"] == pytest.approx(-300.0)
@pytest.mark.asyncio
async def test_total_balance_backtracks_shared_credit_balance_across_all_cards(
session, test_user, test_workspace, test_connection,
):
group = "pluggy:connection:shared-credit"
first = await _make_account(
session, test_user.id, "Shared Visa", acc_type="credit_card", balance="300.00",
connection_id=test_connection.id,
)
second = await _make_account(
session, test_user.id, "Shared Mastercard", acc_type="credit_card", balance="300.00",
connection_id=test_connection.id,
)
for account in (first, second):
account.workspace_id = test_workspace.id
account.shared_balance_group = group
await session.commit()
await _add_txn(session, test_user.id, first.id, 50, "debit", date.today())
await _add_txn(session, test_user.id, second.id, 25, "debit", date.today())
totals = await _total_balance_by_currency(
session, test_workspace.id, date.today() - timedelta(days=1)
)
assert totals["BRL"] == pytest.approx(-225.0)
# ---------------------------------------------------------------------------
# get_summary
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_get_summary_basic(session: AsyncSession, test_user, test_workspace):
"""Summary returns correct structure with balances and counts."""
account = await _make_account(session, test_user.id, "Summary Acc")
today = date.today()
await _add_txn(session, test_user.id, account.id, 5000, "credit", today, source="opening_balance")
await _add_txn(session, test_user.id, account.id, 200, "debit", today)
await _add_txn(session, test_user.id, account.id, 100, "credit", today)
summary = await get_summary(session, test_workspace.id, test_user.id)
assert summary.monthly_income == pytest.approx(100.0)
assert summary.monthly_expenses == pytest.approx(200.0)
assert summary.accounts_count >= 1
# ---------------------------------------------------------------------------
# get_summary: mixed currencies and the FX fallback flag (issue #1165)
# ---------------------------------------------------------------------------
async def _fund_manual(
session: AsyncSession, user_id: uuid.UUID, account_id: uuid.UUID,
amount: float, currency: str,
) -> Transaction:
"""Opening credit for a manual account, in the account's own currency.
Manual account totals count transactions, not the balance field.
"""
txn = Transaction(
id=uuid.uuid4(), user_id=user_id, account_id=account_id,
description="Opening balance", amount=Decimal(str(amount)),
date=app_today(), type="credit", source="opening_balance",
currency=currency, status="posted",
)
session.add(txn)
await session.commit()
return txn
@pytest.mark.asyncio
async def test_get_summary_mixed_currency_missing_rate_flags_fallback(
session: AsyncSession, test_user, test_workspace, monkeypatch
):
"""No FX rate: foreign buckets stay at 1:1 and the summary is flagged.
The total keeps the native amounts (same rule as the available balance
headline) but must carry fx_fallback, so the UI shows the estimate
instead of presenting foreign money as converted (issue #1165).
"""
from unittest.mock import AsyncMock
import app.services.fx_rate_service as fx
# Hermetic: never touch the network, even if a provider API key is set.
monkeypatch.setattr(fx, "sync_rates", AsyncMock(return_value=0))
home = await _make_account(session, test_user.id, "Home", currency="BRL")
abroad = await _make_account(session, test_user.id, "Abroad", currency="EUR")
await _fund_manual(session, test_user.id, home.id, 100.0, "BRL")
await _fund_manual(session, test_user.id, abroad.id, 50.0, "EUR")
summary = await get_summary(session, test_workspace.id, test_user.id)
assert summary.primary_currency == "BRL"
assert summary.total_balance == {"BRL": 100.0, "EUR": 50.0}
# Summed at 1:1 (not silently converted) and flagged as an estimate.
assert summary.total_balance_primary == pytest.approx(150.0)
assert summary.fx_fallback is True
@pytest.mark.asyncio
async def test_get_summary_zero_foreign_balance_without_rate_is_not_flagged(
session: AsyncSession, test_user, test_workspace, monkeypatch
):
"""A foreign account at zero needs no rate: the total is exact, so the
summary must not be flagged as an estimate (issue #1165)."""
from unittest.mock import AsyncMock
import app.services.fx_rate_service as fx
monkeypatch.setattr(fx, "sync_rates", AsyncMock(return_value=0))
home = await _make_account(session, test_user.id, "Home", currency="BRL")
abroad = await _make_account(session, test_user.id, "Abroad", currency="EUR")
await _fund_manual(session, test_user.id, home.id, 100.0, "BRL")
await _fund_manual(session, test_user.id, abroad.id, 50.0, "EUR")
session.add(Transaction(
id=uuid.uuid4(), user_id=test_user.id, account_id=abroad.id,
description="Spent it all", amount=Decimal("50"), date=app_today(),
type="debit", source="manual", currency="EUR", status="posted",
))
await session.commit()
summary = await get_summary(session, test_workspace.id, test_user.id)
assert summary.total_balance_primary == pytest.approx(100.0)
assert summary.fx_fallback is False
@pytest.mark.asyncio
async def test_get_summary_mixed_currency_with_rate_converts(
session: AsyncSession, test_user, test_workspace, monkeypatch
):
"""A real stored rate converts the bucket and no fallback flag is set."""
from unittest.mock import AsyncMock
import app.core.app_clock as clock
import app.services.fx_rate_service as fx
from app.models.fx_rate import FxRate
# Hermetic: never touch the network, even if a provider API key is set.
monkeypatch.setattr(fx, "sync_rates", AsyncMock(return_value=0))
home = await _make_account(session, test_user.id, "Home", currency="BRL")
abroad = await _make_account(session, test_user.id, "Abroad", currency="EUR")
await _fund_manual(session, test_user.id, home.id, 100.0, "BRL")
await _fund_manual(session, test_user.id, abroad.id, 50.0, "EUR")
today = clock.app_today()
session.add(FxRate(base_currency="USD", quote_currency="EUR", date=today, rate=Decimal("1.10"), source="test"))
session.add(FxRate(base_currency="USD", quote_currency="BRL", date=today, rate=Decimal("5.50"), source="test"))
await session.commit()
summary = await get_summary(session, test_workspace.id, test_user.id)
# EUR -> BRL cross rate = 5.50 / 1.10 = 5.00, so 50 EUR counts as 250 BRL.
assert summary.total_balance_primary == pytest.approx(350.0)
assert summary.fx_fallback is False
@pytest.mark.asyncio
async def test_summary_keeps_closed_account_history_and_matches_drilldown(
session: AsyncSession, test_user, test_workspace
):
"""Closing an account stops it counting as current money, not as history.
Past income and expenses of a closed account stay in the month's totals
(issue #1112), and the drill-down behind those totals lists the same rows.
"""
month = (date.today().replace(day=1) - timedelta(days=1)).replace(day=1)
month_start, month_end = _month_range(month)
open_account = await _make_account(session, test_user.id, "Open")
closed_account = await _make_account(
session, test_user.id, "Closed", is_closed=True
)
await _add_txn(session, test_user.id, open_account.id, 100, "credit", month_start)
await _add_txn(session, test_user.id, open_account.id, 40, "debit", month_start)
await _add_txn(session, test_user.id, closed_account.id, 900, "credit", month_start)
await _add_txn(session, test_user.id, closed_account.id, 800, "debit", month_start)
summary = await get_summary(session, test_workspace.id, test_user.id, month=month)
rows, _, _ = await get_transactions(
session,
test_workspace.id,
test_user.id,
from_date=month_start,
to_date=month_end - timedelta(days=1),
skip_pagination=True,
user_pnl_only=True,
)
assert {row.account_id for row in rows} == {open_account.id, closed_account.id}
assert summary.monthly_income == pytest.approx(1000.0)
assert summary.monthly_expenses == pytest.approx(840.0)
assert summary.monthly_income == pytest.approx(
sum(float(row.amount) for row in rows if row.type == "credit")
)
assert summary.monthly_expenses == pytest.approx(
sum(float(row.amount) for row in rows if row.type == "debit")
)
@pytest.mark.asyncio
async def test_closed_account_balance_stays_out_of_current_totals(
session: AsyncSession, test_user, test_workspace
):
"""History of a closed account counts; its balance does not."""
month = date.today().replace(day=1)
open_account = await _make_account(session, test_user.id, "Open")
closed_account = await _make_account(
session, test_user.id, "Closed", is_closed=True
)
await _add_txn(session, test_user.id, open_account.id, 100, "credit", month)
await _add_txn(session, test_user.id, closed_account.id, 250, "credit", month)
summary = await get_summary(session, test_workspace.id, test_user.id, month=month)
assert summary.monthly_income == pytest.approx(350.0)
assert summary.total_balance.get("BRL", 0.0) == pytest.approx(100.0)
accounts = await _get_open_accounts(session, test_workspace.id)
assert {a.id for a in accounts} == {open_account.id}
@pytest.mark.asyncio
async def test_spending_and_trend_keep_closed_account_history(
session: AsyncSession, test_user, test_workspace
):
cat = await _make_category(session, test_user.id, "Savings fees")
closed_account = await _make_account(
session, test_user.id, "Closed saver", is_closed=True
)
today = date.today()
await _add_txn(session, test_user.id, closed_account.id, 60, "debit", today, category_id=cat.id)
spending = await get_spending_by_category(session, test_workspace.id, test_user.id)
fees = next((s for s in spending if s.category_id == str(cat.id)), None)
assert fees is not None and fees.total == pytest.approx(60.0)
trend = await get_monthly_trend(session, test_workspace.id, test_user.id, months=1)
assert sum(point.expenses for point in trend) == pytest.approx(60.0)
@pytest.mark.asyncio
async def test_get_summary_excludes_opening_balance_from_income(session: AsyncSession, test_user, test_workspace):
"""Opening balance does not count as monthly income."""
account = await _make_account(session, test_user.id, "No OB Income")
await _add_txn(session, test_user.id, account.id, 10000, "credit", date.today(), source="opening_balance")
summary = await get_summary(session, test_workspace.id, test_user.id)
assert summary.monthly_income == pytest.approx(0.0)
@pytest.mark.asyncio
async def test_get_summary_excludes_transfers(session: AsyncSession, test_user, test_workspace):
"""Transfer pair transactions excluded from income/expenses."""
account = await _make_account(session, test_user.id, "Transfer Excl")
today = date.today()
pair_id = uuid.uuid4()
await _add_txn(session, test_user.id, account.id, 500, "debit", today, transfer_pair_id=pair_id)
await _add_txn(session, test_user.id, account.id, 100, "debit", today)
summary = await get_summary(session, test_workspace.id, test_user.id)
assert summary.monthly_expenses == pytest.approx(100.0)
@pytest.mark.asyncio
async def test_get_summary_excludes_pending_from_period_totals(
session: AsyncSession, test_user, test_workspace
):
"""Pending (not yet settled) transactions stay out of monthly income/expenses."""
account = await _make_account(session, test_user.id, "Pending Excl")
today = date.today()
await _add_txn(session, test_user.id, account.id, 100, "debit", today)
await _add_txn(session, test_user.id, account.id, 50, "credit", today)
await _add_txn(session, test_user.id, account.id, 10000, "debit", today, status="pending")
await _add_txn(session, test_user.id, account.id, 9000, "credit", today, status="pending")
summary = await get_summary(session, test_workspace.id, test_user.id)
assert summary.monthly_expenses == pytest.approx(100.0)
assert summary.monthly_income == pytest.approx(50.0)
@pytest.mark.asyncio
async def test_get_summary_pending_categorization(session: AsyncSession, test_user, test_workspace):
"""Summary counts uncategorized transactions."""
account = await _make_account(session, test_user.id, "Pending Cat")
today = date.today()
# 2 uncategorized, 1 opening_balance (excluded)
await _add_txn(session, test_user.id, account.id, 100, "debit", today)
await _add_txn(session, test_user.id, account.id, 200, "debit", today)
await _add_txn(session, test_user.id, account.id, 5000, "credit", today, source="opening_balance")
summary = await get_summary(session, test_workspace.id, test_user.id)
assert summary.pending_categorization >= 2
@pytest.mark.asyncio
async def test_get_summary_with_specific_month(session: AsyncSession, test_user, test_workspace):
"""Summary uses the specified month."""
account = await _make_account(session, test_user.id, "Month Test")
today = date.today()
past = (today.replace(day=1) - timedelta(days=1)).replace(day=15)
await _add_txn(session, test_user.id, account.id, 300, "debit", past)
# Current month - no transactions
await get_summary(session, test_workspace.id, test_user.id, month=today.replace(day=1))
# Past month - has 300 debit
summary_past = await get_summary(session, test_workspace.id, test_user.id, month=past.replace(day=1))
assert summary_past.monthly_expenses >= 300.0
@pytest.mark.asyncio
async def test_get_summary_with_balance_date(session: AsyncSession, test_user, test_workspace):
"""balance_date overrides the default cutoff for balance calculation."""
account = await _make_account(session, test_user.id, "Balance Date")
today = date.today()
await _add_txn(session, test_user.id, account.id, 1000, "credit", today - timedelta(days=10))
await _add_txn(session, test_user.id, account.id, 500, "debit", today - timedelta(days=3))
# With cutoff 5 days ago, the 500 debit shouldn't be included
summary = await get_summary(
session, test_workspace.id, test_user.id, month=today.replace(day=1),
balance_date=today - timedelta(days=5),
)
total = sum(summary.total_balance.values())
assert total == pytest.approx(1000.0)
# ---------------------------------------------------------------------------
# get_spending_by_category
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_spending_by_category_basic(session: AsyncSession, test_user, test_workspace):
"""Returns spending grouped by category."""
cat = await _make_category(session, test_user.id, "Food", color="#F00")
account = await _make_account(session, test_user.id, "Spend Test")
today = date.today()
await _add_txn(session, test_user.id, account.id, 100, "debit", today, category_id=cat.id)
await _add_txn(session, test_user.id, account.id, 50, "debit", today, category_id=cat.id)
spending = await get_spending_by_category(session, test_workspace.id, test_user.id)
assert len(spending) > 0
food = next((s for s in spending if s.category_id == str(cat.id)), None)
assert food is not None
assert food.total == pytest.approx(150.0)
@pytest.mark.asyncio
async def test_spending_by_category_uncategorized(session: AsyncSession, test_user, test_workspace):
"""Uncategorized transactions show as 'Sem categoria'."""
account = await _make_account(session, test_user.id, "Uncat Spend")
today = date.today()
await _add_txn(session, test_user.id, account.id, 75, "debit", today)
spending = await get_spending_by_category(session, test_workspace.id, test_user.id)
uncat = next((s for s in spending if s.category_id is None), None)
assert uncat is not None
assert uncat.category_name == "Sem categoria"
@pytest.mark.asyncio
async def test_spending_excludes_credits(session: AsyncSession, test_user, test_workspace):
"""Spending by category only includes debit transactions."""
cat = await _make_category(session, test_user.id, "Income Cat")
account = await _make_account(session, test_user.id, "Credit Excl")
today = date.today()
await _add_txn(session, test_user.id, account.id, 1000, "credit", today, category_id=cat.id)
spending = await get_spending_by_category(session, test_workspace.id, test_user.id)
income = next((s for s in spending if s.category_id == str(cat.id)), None)
assert income is None
@pytest.mark.asyncio
async def test_spending_excludes_transfers(session: AsyncSession, test_user, test_workspace):
"""Transfer pairs are excluded from spending."""
account = await _make_account(session, test_user.id, "Transfer Spend")
today = date.today()
pair_id = uuid.uuid4()
await _add_txn(session, test_user.id, account.id, 500, "debit", today, transfer_pair_id=pair_id)
spending = await get_spending_by_category(session, test_workspace.id, test_user.id)
# No spending should include the transfer
total = sum(s.total for s in spending)
assert 500 not in [s.total for s in spending] or total == 0
@pytest.mark.asyncio
async def test_spending_excludes_opening_balance(session: AsyncSession, test_user, test_workspace):
"""A debt carried in as an opening balance is not spending, so the
breakdown still adds up to the expenses card."""
cat = await _make_category(session, test_user.id, "Groceries")
account = await _make_account(session, test_user.id, "OB Card", acc_type="credit_card")
today = date.today()
await _add_txn(session, test_user.id, account.id, 2500, "debit", today, source="opening_balance")
await _add_txn(session, test_user.id, account.id, 40, "debit", today, category_id=cat.id)
spending = await get_spending_by_category(session, test_workspace.id, test_user.id)
assert next((s for s in spending if s.category_id is None), None) is None
assert sum(s.total for s in spending) == pytest.approx(40.0)
summary = await get_summary(session, test_workspace.id, test_user.id)
assert sum(s.total for s in spending) == pytest.approx(summary.monthly_expenses)
@pytest.mark.asyncio
async def test_spending_percentage(session: AsyncSession, test_user, test_workspace):
"""Percentages sum to approximately 100%."""
cat1 = await _make_category(session, test_user.id, "Cat A")
cat2 = await _make_category(session, test_user.id, "Cat B")
account = await _make_account(session, test_user.id, "Pct Test")
today = date.today()
await _add_txn(session, test_user.id, account.id, 300, "debit", today, category_id=cat1.id)
await _add_txn(session, test_user.id, account.id, 700, "debit", today, category_id=cat2.id)
spending = await get_spending_by_category(session, test_workspace.id, test_user.id)
total_pct = sum(s.percentage for s in spending)
assert total_pct == pytest.approx(100.0, abs=0.1)
# ---------------------------------------------------------------------------
# get_projected_transactions
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_get_projected_transactions(session: AsyncSession, test_user, test_workspace):
"""Projected transactions include recurring template details."""
cat = await _make_category(session, test_user.id, "Recurring Cat")
# Create a recurring transaction for next month
next_month = date.today().replace(day=1)
if next_month.month == 12:
next_month = next_month.replace(year=next_month.year + 1, month=1)
else:
next_month = next_month.replace(month=next_month.month + 1)
from datetime import datetime, timezone
rec = RecurringTransaction(
id=uuid.uuid4(), user_id=test_user.id,
description="Weekly Coffee", amount=Decimal("25.00"),
currency="BRL", type="debit", frequency="weekly",
start_date=next_month, next_occurrence=next_month,
is_active=True, category_id=cat.id,
created_at=datetime.now(timezone.utc),
)
session.add(rec)
await session.commit()
projections = await get_projected_transactions(session, test_workspace.id, test_user.id, month=next_month)
assert len(projections) >= 4 # Weekly = at least 4 occurrences
for proj in projections:
assert proj.description == "Weekly Coffee"
assert proj.amount == 25.0
assert proj.category_name == "Recurring Cat"
@pytest.mark.asyncio
async def test_get_projected_transactions_no_category(session: AsyncSession, test_user, test_workspace):
"""Projected transactions work without category."""
next_month = date.today().replace(day=1)
if next_month.month == 12:
next_month = next_month.replace(year=next_month.year + 1, month=1)
else:
next_month = next_month.replace(month=next_month.month + 1)
from datetime import datetime, timezone
rec = RecurringTransaction(
id=uuid.uuid4(), user_id=test_user.id,
description="Monthly Fee", amount=Decimal("50.00"),
currency="BRL", type="debit", frequency="monthly",
start_date=next_month, next_occurrence=next_month,
is_active=True, category_id=None,
created_at=datetime.now(timezone.utc),
)
session.add(rec)
await session.commit()
projections = await get_projected_transactions(session, test_workspace.id, test_user.id, month=next_month)
assert len(projections) >= 1
proj = projections[0]
assert proj.category_name is None
assert proj.category_id is None
@pytest.mark.asyncio
async def test_get_projected_transactions_shows_transfer_like_but_not_ignored_categories(
session: AsyncSession, test_user, test_workspace
):
"""Transfer/investment rows are visible projections without becoming P&L."""
month_start = date.today().replace(day=1)
transfer_like = Category(
id=uuid.uuid4(),
user_id=test_user.id,
workspace_id=test_workspace.id,
name="Investments",
icon="trending-up",
color="#0EA5E9",
treat_as_transfer=True,
)
ignored = Category(
id=uuid.uuid4(),
user_id=test_user.id,
workspace_id=test_workspace.id,
name="Ignored",
is_ignored=True,
)
session.add_all([transfer_like, ignored])
for description, category_id in (
("Monthly investment", transfer_like.id),
("Hidden recurring", ignored.id),
):
session.add(RecurringTransaction(
id=uuid.uuid4(),
user_id=test_user.id,
workspace_id=test_workspace.id,
description=description,
amount=Decimal("100"),
currency="BRL",
type="debit",
frequency="monthly",
start_date=month_start,
next_occurrence=month_start,
is_active=True,
category_id=category_id,
))
await session.commit()
projections = await get_projected_transactions(
session, test_workspace.id, test_user.id, month=month_start
)
by_description = {p.description: p for p in projections}
assert by_description["Monthly investment"].category_name == "Investments"
assert "Hidden recurring" not in by_description
@pytest.mark.asyncio
async def test_account_balance_manual_future_date(session, test_user):
acct = Account(
id=uuid.uuid4(), user_id=test_user.id, name="FutDate",
type="checking", balance=Decimal("0"), currency="BRL",
)
session.add(acct)
await session.commit()
await session.refresh(acct)
today = date.today()
from datetime import datetime, timezone
txn = Transaction(
id=uuid.uuid4(), user_id=test_user.id, account_id=acct.id,
description="Today only", amount=Decimal("500"), date=today,
type="credit", source="manual", currency="BRL",
created_at=datetime.now(timezone.utc),
)
session.add(txn)
await session.commit()
yesterday = today - timedelta(days=1)
bal = await _account_balance_at(session, acct, yesterday)
assert bal == 0.0
@pytest.mark.asyncio
async def test_account_balance_bank_credit_card(session, test_user):
from datetime import datetime, timezone
conn = BankConnection(
id=uuid.uuid4(), user_id=test_user.id, provider="test",
external_id="ext-cc-ds", institution_name="CC Bank",
credentials={}, status="active",
last_sync_at=datetime.now(timezone.utc),
created_at=datetime.now(timezone.utc),
)
session.add(conn)
await session.flush()
cc = Account(
id=uuid.uuid4(), user_id=test_user.id, connection_id=conn.id,
name="CC", type="credit_card", balance=Decimal("1500"), currency="BRL",
)
session.add(cc)
await session.commit()
await session.refresh(cc)
bal = await _account_balance_at(session, cc, date.today())
assert bal == -1500.0
@pytest.mark.asyncio
async def test_get_open_accounts_excludes_closed(session, test_user, test_workspace):
closed = Account(
id=uuid.uuid4(), user_id=test_user.id, name="Closed",
type="checking", balance=Decimal("0"), currency="BRL", is_closed=True,
)
session.add(closed)
await session.commit()
accounts = await _get_open_accounts(session, test_workspace.id)
assert all(a.id != closed.id for a in accounts)
@pytest.mark.asyncio
async def test_balance_at_single_currency(session, test_user, test_workspace):
acct = Account(
id=uuid.uuid4(), user_id=test_user.id, name="BalAt",
type="checking", balance=Decimal("0"), currency="BRL",
)
session.add(acct)
await session.commit()
from datetime import datetime, timezone
txn = Transaction(
id=uuid.uuid4(), user_id=test_user.id, account_id=acct.id,
description="Income", amount=Decimal("3000"), date=date.today(),
type="credit", source="manual", currency="BRL",
created_at=datetime.now(timezone.utc),
)
session.add(txn)
await session.commit()
bal = await _balance_at(session, test_workspace.id, date.today())
assert bal >= 3000.0
@pytest.mark.asyncio
async def test_get_summary_past_month(session, test_user, test_workspace):
past = date.today().replace(day=1) - timedelta(days=30)
past_month = past.replace(day=1)
summary = await get_summary(session, test_workspace.id, test_user.id, month=past_month)
assert summary is not None
@pytest.mark.asyncio
async def test_spending_by_category_with_categorized(session, test_user, test_workspace, test_categories):
acct = Account(
id=uuid.uuid4(), user_id=test_user.id, name="SpendCat",
type="checking", balance=Decimal("0"), currency="BRL",
)
session.add(acct)
await session.commit()
from datetime import datetime, timezone
txn = Transaction(
id=uuid.uuid4(), user_id=test_user.id, account_id=acct.id,
category_id=test_categories[0].id,
description="Food", amount=Decimal("200"), date=date.today(),
type="debit", source="manual", currency="BRL",
created_at=datetime.now(timezone.utc),
)
session.add(txn)
await session.commit()
result = await get_spending_by_category(session, test_workspace.id, test_user.id)
cat_names = [s.category_name for s in result]
assert test_categories[0].name in cat_names
@pytest.mark.asyncio
async def test_get_recurring_projections(session, test_user, test_workspace):
today = date.today()
month_start = today.replace(day=1)
if today.month == 12:
month_end = date(today.year + 1, 1, 1)
else:
month_end = date(today.year, today.month + 1, 1)
rec = RecurringTransaction(
id=uuid.uuid4(), user_id=test_user.id,
description="Rent", amount=Decimal("2000"), type="debit",
frequency="monthly", start_date=month_start,
next_occurrence=month_start, currency="BRL",
)
session.add(rec)
await session.commit()
projections = await _get_recurring_projections(session, test_workspace.id, month_start, month_end)
assert len(projections) >= 1
assert projections[0]["amount"] == 2000.0
@pytest.mark.asyncio
async def test_get_recurring_projections_filters_non_pnl_categories_by_default(
session, test_user, test_workspace
):
month_start = date.today().replace(day=1)
month_end = (
date(month_start.year + 1, 1, 1)
if month_start.month == 12
else date(month_start.year, month_start.month + 1, 1)
)
ignored = Category(
id=uuid.uuid4(),
user_id=test_user.id,
workspace_id=test_workspace.id,
name="Ignored",
is_ignored=True,
)
transfer_like = Category(
id=uuid.uuid4(),
user_id=test_user.id,
workspace_id=test_workspace.id,
name="Transfer",
treat_as_transfer=True,
)
session.add_all([ignored, transfer_like])
await session.commit()
for description, amount, category_id in (
("Counted", "100", None),
("Ignored", "200", ignored.id),
("Transfer-like", "300", transfer_like.id),
):
session.add(RecurringTransaction(
id=uuid.uuid4(),
user_id=test_user.id,
workspace_id=test_workspace.id,
description=description,
amount=Decimal(amount),
type="debit",
frequency="monthly",
start_date=month_start,
next_occurrence=month_start,
currency="BRL",
category_id=category_id,
))
await session.commit()
projections = await _get_recurring_projections(
session, test_workspace.id, month_start, month_end
)
balance_projections = await _get_recurring_projections(
session,
test_workspace.id,
month_start,
month_end,
include_transfer_like=True,
)
assert [p["amount"] for p in projections] == [100.0]
assert {p["amount"] for p in balance_projections} == {100.0, 300.0}
@pytest.mark.asyncio
async def test_balance_history_basic(session, test_user, test_workspace):
acct = Account(
id=uuid.uuid4(), user_id=test_user.id, name="BH",
type="checking", balance=Decimal("0"), currency="BRL",
)
session.add(acct)
await session.commit()
from datetime import datetime, timezone
txn = Transaction(
id=uuid.uuid4(), user_id=test_user.id, account_id=acct.id,
description="BH txn", amount=Decimal("1000"), date=date.today(),
type="credit", source="manual", currency="BRL",
created_at=datetime.now(timezone.utc),
)
session.add(txn)
await session.commit()
history = await get_balance_history(session, test_workspace.id, test_user.id)
assert len(history.current) > 0
assert 28 <= len(history.baseline) <= 31
@pytest.mark.asyncio
async def test_balance_history_single_comparison_reuses_month_daily_balances(
session: AsyncSession, test_user, test_workspace
):
account = await _make_account(session, test_user.id, "Single comparison")
account.workspace_id = test_workspace.id
await session.commit()
await _add_txn(
session, test_user.id, account.id, 1000, "credit", date(2026, 1, 1),
source="opening_balance",
)
await _add_txn(session, test_user.id, account.id, 50, "credit", date(2026, 2, 5))
await _add_txn(
session, test_user.id, account.id, 5000, "credit", date(2026, 2, 10),
source="opening_balance",
)
await _add_txn(session, test_user.id, account.id, 5, "debit", date(2026, 2, 20))
history = await get_balance_history(
session,
test_workspace.id,
test_user.id,
month=date(2026, 4, 1),
account_ids=[account.id],
comparison_months=[date(2026, 2, 1)],
)
assert history.comparison_month == "2026-02"
assert history.comparison_opening_balance == 1000.0
assert history.comparison is not None
assert len(history.comparison) == 28
assert history.comparison[0].balance == 1000.0
assert history.comparison[4].balance == 1050.0
assert history.comparison[9].balance == 1050.0
assert history.comparison[5].balance == 1050.0
assert history.comparison[19].balance == 1045.0
assert history.baseline == []
@pytest.mark.asyncio
async def test_midmonth_opening_balances_are_excluded_from_current_and_baseline(
session: AsyncSession, test_user, test_workspace
):
account = await _make_account(session, test_user.id, "Opening balance consistency")
account.workspace_id = test_workspace.id
await session.commit()
for month, amount in ((1, 10), (2, 20), (3, 30), (4, 40)):
await _add_txn(
session, test_user.id, account.id, 1000, "credit", date(2026, month, 15),
source="opening_balance",
)
await _add_txn(
session, test_user.id, account.id, amount, "credit", date(2026, month, 20)
)
history = await get_balance_history(
session,
test_workspace.id,
test_user.id,
month=date(2026, 4, 1),
account_ids=[account.id],
comparison_months=[date(2026, month, 1) for month in (1, 2, 3)],
)
current_change = [
point.balance - history.opening_balance
for point in history.current
if point.balance is not None
]
assert current_change[14] == 0.0
assert current_change[19] == 40.0
assert history.baseline[14].median == 0.0
assert history.baseline[19].median == 20.0
@pytest.mark.asyncio
async def test_balance_history_single_comparison_stops_at_today(
session: AsyncSession, test_user, test_workspace, monkeypatch
):
monkeypatch.setattr(
"app.services.dashboard_service.app_today", lambda: date(2026, 10, 18)
)
account = await _make_account(session, test_user.id, "In-progress comparison")
account.workspace_id = test_workspace.id
await session.commit()
await _add_txn(session, test_user.id, account.id, 50, "credit", date(2026, 10, 5))
history = await get_balance_history(
session,
test_workspace.id,
test_user.id,
month=date(2026, 11, 1),
account_ids=[account.id],
comparison_months=[date(2026, 10, 1)],
)
assert history.comparison is not None
assert len(history.comparison) == 31
assert history.comparison[17].balance is not None
assert all(point.balance is None for point in history.comparison[18:])
@pytest.mark.asyncio
async def test_balance_history_sparse_month_selection_excludes_gap_month(
session: AsyncSession, test_user, test_workspace
):
account = await _make_account(session, test_user.id, "Sparse comparisons")
account.workspace_id = test_workspace.id
await session.commit()
await _add_txn(session, test_user.id, account.id, 10, "credit", date(2026, 1, 1))
await _add_txn(session, test_user.id, account.id, 1000, "credit", date(2026, 2, 1))
await _add_txn(session, test_user.id, account.id, 30, "credit", date(2026, 3, 1))
history = await get_balance_history(
session,
test_workspace.id,
test_user.id,
month=date(2026, 4, 1),
account_ids=[account.id],
comparison_months=[date(2026, 3, 1), date(2026, 1, 1)],
)
assert history.comparison is None
assert history.baseline[0].median == 20.0
assert history.baseline[0].lower_quartile is None
assert history.baseline[0].upper_quartile is None
@pytest.mark.asyncio
async def test_balance_history_month_options_are_scoped_and_exclude_openings(
session: AsyncSession, test_user, test_workspace
):
first = await _make_account(session, test_user.id, "Month options one")
second = await _make_account(session, test_user.id, "Month options two")
first.workspace_id = test_workspace.id
second.workspace_id = test_workspace.id
await session.commit()
await _add_txn(
session, test_user.id, first.id, 500, "credit", date(2026, 1, 1),
source="opening_balance",
)
await _add_txn(session, test_user.id, first.id, 25, "credit", date(2026, 2, 1))
await _add_txn(session, test_user.id, second.id, 75, "credit", date(2026, 3, 1))
all_months = await get_balance_history_months(session, test_workspace.id)
first_account_months = await get_balance_history_months(
session, test_workspace.id, [first.id]
)
assert all_months == ["2026-02", "2026-03"]
assert first_account_months == ["2026-02"]
@pytest.mark.asyncio
async def test_balance_history_month_options_exclude_loans(
session: AsyncSession, test_user, test_workspace
):
# Loans are left out of the balance curve, so their months have no data to plot.
checking = await _make_account(session, test_user.id, "Months checking")
loan = await _make_account(session, test_user.id, "Months loan", acc_type="loan")
checking.workspace_id = test_workspace.id
loan.workspace_id = test_workspace.id
await session.commit()
await _add_txn(session, test_user.id, checking.id, 25, "credit", date(2026, 2, 1))
await _add_txn(session, test_user.id, loan.id, 300, "debit", date(2026, 3, 1))
assert await get_balance_history_months(session, test_workspace.id) == ["2026-02"]
assert await get_balance_history_months(
session, test_workspace.id, [checking.id, loan.id]
) == ["2026-02"]
def test_baseline_from_deltas_median_and_quartiles():
# Four months; day-1 changes are -10, -20, -30, -40.
deltas = {
date(2026, 1, 1): -10.0,
date(2026, 2, 1): -20.0,
date(2026, 3, 1): -30.0,
date(2026, 4, 1): -40.0,
}
month_starts = [date(2026, month, 1) for month in range(1, 5)]
baseline = _baseline_from_deltas(deltas, month_starts, 31, date.max)
assert len(baseline) == 31
day1 = baseline[0]
assert day1.median == -25.0
assert day1.lower_quartile == -32.5
assert day1.upper_quartile == -17.5
assert baseline[1].median == -25.0
def test_baseline_three_contributors_include_quartiles():
deltas = {
date(2026, 1, 1): 10.0,
date(2026, 2, 1): 20.0,
date(2026, 3, 1): 30.0,
}
baseline = _baseline_from_deltas(
deltas,
[date(2026, 1, 1), date(2026, 2, 1), date(2026, 3, 1)],
30,
date.max,
)
assert baseline[0].median == 20.0
assert baseline[0].lower_quartile == 15.0
assert baseline[0].upper_quartile == 25.0
def test_normalize_comparison_months_defaults_and_deduplicates():
from app.services.dashboard_service import _normalize_comparison_months
default = _normalize_comparison_months(None, date(2026, 10, 1))
selected = _normalize_comparison_months(
[date(2026, 3, 15), date(2026, 1, 1), date(2026, 3, 1)],
date(2026, 10, 1),
)
assert len(default) == 12
assert selected == [date(2026, 1, 1), date(2026, 3, 1)]
@pytest.mark.parametrize(
"months",
[
pytest.param([], id="empty"),
pytest.param([date(2026, 10, 1)], id="not-before-viewed-month"),
pytest.param(
[date(2024 + index // 12, index % 12 + 1, 1) for index in range(25)],
id="more-than-24-months",
),
],
)
def test_normalize_comparison_months_rejects_invalid_selections(months):
from app.services.dashboard_service import _normalize_comparison_months
with pytest.raises(ValueError):
_normalize_comparison_months(months, date(2026, 10, 1))
def test_baseline_aligns_month_end_income():
# Salary of +100 on the last day of Jan (31), Feb (28), Mar (31), Apr (30).
deltas = {
date(2026, 1, 31): 100.0,
date(2026, 2, 28): 100.0,
date(2026, 3, 31): 100.0,
date(2026, 4, 30): 100.0,
}
for target_days in (28, 30, 31):
month_starts = [date(2026, month, 1) for month in range(1, 5)]
baseline = _baseline_from_deltas(deltas, month_starts, target_days, date.max)
assert len(baseline) == target_days
assert baseline[-1].median == 100.0
assert baseline[0].median == 0.0
def test_baseline_two_months_has_median_without_quartiles():
deltas = {date(2026, 1, 5): 10.0, date(2026, 2, 5): 20.0}
month_starts = [date(2026, month, 1) for month in range(1, 13)]
baseline = _baseline_from_deltas(deltas, month_starts, 30, date.max)
assert baseline[4].median == 15.0
assert baseline[4].lower_quartile is None
assert baseline[4].upper_quartile is None
def test_baseline_omits_source_days_after_today():
# Viewing a future month: the in-progress month must not carry its
# balance flat past today and drag the median.
deltas = {
date(2026, 8, 1): 10.0,
date(2026, 9, 1): 20.0,
date(2026, 10, 1): 30.0,
date(2026, 10, 20): 1000.0,
}
month_starts = [date(2026, 8, 1), date(2026, 9, 1), date(2026, 10, 1)]
baseline = _baseline_from_deltas(deltas, month_starts, 30, date(2026, 10, 18))
assert baseline[17].median == 20.0 # day 18: Aug, Sep, Oct all count
assert baseline[18].median == 15.0 # day 19: only Aug and Sep
assert baseline[18].lower_quartile is None
@pytest.mark.asyncio
async def test_future_balance_history_carries_pending_into_projected_opening(
session: AsyncSession, test_user, test_workspace
):
account = Account(
id=uuid.uuid4(), user_id=test_user.id, workspace_id=test_workspace.id,
name="Future balance", type="checking", balance=Decimal("0"), currency="BRL",
)
opening = Transaction(
id=uuid.uuid4(), user_id=test_user.id, workspace_id=test_workspace.id,
account_id=account.id, description="Opening", amount=Decimal("1000"),
currency="BRL", date=date.today(), type="credit", source="opening_balance",
status="posted",
)
pending = Transaction(
id=uuid.uuid4(), user_id=test_user.id, workspace_id=test_workspace.id,
account_id=account.id, description="Pending bill", amount=Decimal("100"),
currency="BRL", date=date.today(), type="debit", source="sync",
status="pending",
)
session.add_all([account, opening, pending])
await session.commit()
next_month = (date.today().replace(day=1) + timedelta(days=32)).replace(day=1)
history = await get_balance_history(
session, test_workspace.id, test_user.id,
month=next_month, account_ids=[account.id],
)
assert history.current[0].balance == 900.0
@pytest.mark.asyncio
async def test_balance_history_ignored_category_is_consistent_across_months(
session: AsyncSession, test_user, test_workspace
):
account = Account(
id=uuid.uuid4(),
user_id=test_user.id,
workspace_id=test_workspace.id,
name="Ignored boundary",
type="checking",
balance=Decimal("0"),
currency="BRL",
)
ignored = Category(
id=uuid.uuid4(),
user_id=test_user.id,
workspace_id=test_workspace.id,
name="Ignored",
is_ignored=True,
)
session.add_all([account, ignored])
await session.flush()
session.add_all([
Transaction(
id=uuid.uuid4(),
user_id=test_user.id,
workspace_id=test_workspace.id,
account_id=account.id,
description="Opening",
amount=Decimal("1000"),
currency="BRL",
date=date(2026, 7, 1),
type="credit",
source="opening_balance",
),
Transaction(
id=uuid.uuid4(),
user_id=test_user.id,
workspace_id=test_workspace.id,
account_id=account.id,
category_id=ignored.id,
description="Ignored debit",
amount=Decimal("100"),
currency="BRL",
date=date(2026, 8, 3),
type="debit",
source="manual",
is_ignored=False,
),
])
await session.commit()
august = await get_balance_history(
session,
test_workspace.id,
test_user.id,
month=date(2026, 8, 1),
account_ids=[account.id],
)
september = await get_balance_history(
session,
test_workspace.id,
test_user.id,
month=date(2026, 9, 1),
account_ids=[account.id],
)
august_balance = next(
point.balance for point in reversed(august.current) if point.balance is not None
)
assert august_balance == 1000.0
assert september.current[0].balance == 1000.0
@pytest.mark.asyncio
async def test_balance_history_past_month(session, test_user, test_workspace):
past = date.today().replace(day=1) - timedelta(days=15)
past_month = past.replace(day=1)
history = await get_balance_history(session, test_workspace.id, test_user.id, month=past_month)
assert len(history.current) > 0
# ---------------------------------------------------------------------------
# get_projected_transactions
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_get_projected_transactions_empty(session, test_user, test_workspace):
result = await get_projected_transactions(session, test_workspace.id, test_user.id)
assert result == []
@pytest.mark.asyncio
async def test_get_projected_transactions_with_recurring(session, test_user, test_workspace):
today = date.today()
month_start = today.replace(day=1)
cat = Category(
id=uuid.uuid4(), user_id=test_user.id,
name="Rent", icon="home", color="#000",
)
session.add(cat)
rec = RecurringTransaction(
id=uuid.uuid4(), user_id=test_user.id,
description="Monthly Rent", amount=Decimal("2500"),
type="debit", frequency="monthly", currency="BRL",
start_date=month_start, next_occurrence=month_start,
category_id=cat.id,
)
session.add(rec)
await session.commit()
result = await get_projected_transactions(session, test_workspace.id, test_user.id, month=month_start)
assert len(result) >= 1
assert result[0].description == "Monthly Rent"
assert result[0].category_name == "Rent"
assert result[0].amount == 2500.0
@pytest.mark.asyncio
async def test_projected_transactions_use_effective_month_without_duplicates(
session, test_user, test_workspace
):
rec = RecurringTransaction(
id=uuid.uuid4(),
user_id=test_user.id,
workspace_id=test_workspace.id,
description="Month boundary rent",
amount=Decimal("1000"),
type="debit",
frequency="monthly",
currency="BRL",
start_date=date(2026, 8, 1),
next_occurrence=date(2026, 8, 1),
weekend_adjustment="previous_friday",
)
session.add(rec)
await session.commit()
july = await get_projected_transactions(
session, test_workspace.id, test_user.id, month=date(2026, 7, 1)
)
august = await get_projected_transactions(
session, test_workspace.id, test_user.id, month=date(2026, 8, 1)
)
july_dates = [item.date for item in july if item.recurring_id == str(rec.id)]
august_dates = [item.date for item in august if item.recurring_id == str(rec.id)]
assert july_dates == ["2026-07-31"]
assert august_dates == []
# ---------------------------------------------------------------------------
# get_summary with recurring projections
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_get_summary_includes_recurring_projections(session, test_user, test_workspace):
today = date.today()
month_start = today.replace(day=1)
acct = Account(
id=uuid.uuid4(), user_id=test_user.id, name="Summary Acct",
type="checking", balance=Decimal("5000"), currency="BRL",
)
session.add(acct)
rec = RecurringTransaction(
id=uuid.uuid4(), user_id=test_user.id,
description="Salary", amount=Decimal("10000"),
type="credit", frequency="monthly", currency="BRL",
start_date=month_start, next_occurrence=month_start,
)
session.add(rec)
await session.commit()
summary = await get_summary(session, test_workspace.id, test_user.id, month=month_start)
assert summary.monthly_income == pytest.approx(0.0)
assert summary.projected_income >= 10000.0
# ---------------------------------------------------------------------------
# get_spending_by_category with recurring projections
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_spending_by_category_includes_recurring(session, test_user, test_workspace):
today = date.today()
month_start = today.replace(day=1)
cat = Category(
id=uuid.uuid4(), user_id=test_user.id,
name="Transport", icon="car", color="#3B82F6",
)
session.add(cat)
acct = Account(
id=uuid.uuid4(), user_id=test_user.id, name="Spend Acct",
type="checking", balance=Decimal("0"), currency="BRL",
)
session.add(acct)
rec = RecurringTransaction(
id=uuid.uuid4(), user_id=test_user.id,
description="Gas", amount=Decimal("200"),
type="debit", frequency="monthly", currency="BRL",
start_date=month_start, next_occurrence=month_start,
category_id=cat.id,
)
session.add(rec)
await session.commit()
spending = await get_spending_by_category(session, test_workspace.id, test_user.id, month=month_start)
assert len(spending) >= 1
transport = next((s for s in spending if s.category_name == "Transport"), None)
assert transport is not None
# Recurring projections are forecast: they live in projected_total so the
# posted-only `total` keeps matching the expenses card.
assert transport.total == 0.0
assert transport.projected_total >= 200.0
# ---------------------------------------------------------------------------
# _balance_at multi-currency
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_balance_at_multi_currency(session, test_user, test_workspace):
acct_brl = Account(
id=uuid.uuid4(), user_id=test_user.id, name="BRL Acct",
type="checking", balance=Decimal("0"), currency="BRL",
)
acct_usd = Account(
id=uuid.uuid4(), user_id=test_user.id, name="USD Acct",
type="checking", balance=Decimal("0"), currency="USD",
)
session.add_all([acct_brl, acct_usd])
from datetime import datetime, timezone
for acct, amount in [(acct_brl, Decimal("1000")), (acct_usd, Decimal("200"))]:
txn = Transaction(
id=uuid.uuid4(), user_id=test_user.id, account_id=acct.id,
description="Deposit", amount=amount, date=date.today(),
type="credit", source="manual", currency=acct.currency,
created_at=datetime.now(timezone.utc),
)
session.add(txn)
await session.commit()
total = await _balance_at(session, test_workspace.id, date.today())
assert total > 0
# ---------------------------------------------------------------------------
# _total_balance_by_currency
# ---------------------------------------------------------------------------