Open-source personal finance manager. Self-hosted, privacy-first.
import uuid
from datetime import date
from decimal import Decimal
import pytest
import pytest_asyncio
from pydantic import ValidationError
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.account import Account
from app.models.transaction import Transaction
from app.schemas.recurring_transaction import RecurringTransactionCreate, RecurringTransactionUpdate
from app.services.recurring_transaction_service import (
_advance_date,
adjust_weekend_date,
create_recurring_transaction,
delete_recurring_transaction,
generate_pending,
get_occurrences_in_range,
get_recurring_transaction,
get_recurring_transactions,
update_recurring_transaction,
)
@pytest_asyncio.fixture
async def test_account_for_recurring(session: AsyncSession, test_user) -> Account:
account = Account(
id=uuid.uuid4(),
user_id=test_user.id,
name="RecurAcc",
type="checking",
balance=Decimal("10000"),
currency="BRL",
)
session.add(account)
await session.commit()
await session.refresh(account)
return account
# ---------------------------------------------------------------------------
# CRUD
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_create_recurring_transaction(
session: AsyncSession, test_user, test_workspace, test_account_for_recurring
):
data = RecurringTransactionCreate(
description="Netflix",
amount=Decimal("39.90"),
type="debit",
frequency="monthly",
start_date=date(2025, 1, 15),
account_id=test_account_for_recurring.id,
)
rec = await create_recurring_transaction(session, test_workspace.id, test_user.id, data)
assert rec.id is not None
assert rec.description == "Netflix"
assert rec.amount == Decimal("39.90")
assert rec.frequency == "monthly"
assert rec.next_occurrence == date(2025, 1, 15)
assert rec.is_active is True
@pytest.mark.asyncio
async def test_create_with_skip_first(session: AsyncSession, test_user, test_workspace, test_account_for_recurring):
data = RecurringTransactionCreate(
description="Rent",
amount=Decimal("2000"),
type="debit",
frequency="monthly",
start_date=date(2025, 3, 1),
account_id=test_account_for_recurring.id,
skip_first=True,
)
rec = await create_recurring_transaction(session, test_workspace.id, test_user.id, data)
# skip_first should advance to next month
assert rec.start_date == date(2025, 3, 1)
assert rec.next_occurrence == date(2025, 4, 1)
@pytest.mark.asyncio
async def test_get_recurring_transactions(
session: AsyncSession, test_user, test_workspace, test_account_for_recurring
):
for desc, dt in [("Sub1", date(2025, 1, 1)), ("Sub2", date(2025, 2, 1))]:
await create_recurring_transaction(
session,
test_workspace.id, test_user.id,
RecurringTransactionCreate(
description=desc,
amount=Decimal("10"),
type="debit",
frequency="monthly",
start_date=dt,
account_id=test_account_for_recurring.id,
),
)
result = await get_recurring_transactions(session, test_workspace.id)
assert len(result) >= 2
# Ordered by next_occurrence
dates = [r.next_occurrence for r in result]
assert dates == sorted(dates)
@pytest.mark.asyncio
async def test_get_recurring_transaction_by_id(
session: AsyncSession, test_user, test_workspace, test_account_for_recurring
):
created = await create_recurring_transaction(
session,
test_workspace.id, test_user.id,
RecurringTransactionCreate(
description="Lookup",
amount=Decimal("50"),
type="debit",
frequency="weekly",
start_date=date(2025, 6, 1),
account_id=test_account_for_recurring.id,
),
)
fetched = await get_recurring_transaction(session, created.id, test_workspace.id)
assert fetched is not None
assert fetched.id == created.id
@pytest.mark.asyncio
async def test_get_recurring_transaction_not_found(session: AsyncSession, test_user, test_workspace):
result = await get_recurring_transaction(session, uuid.uuid4(), test_workspace.id)
assert result is None
@pytest.mark.asyncio
async def test_update_recurring_transaction(
session: AsyncSession, test_user, test_workspace, test_account_for_recurring
):
rec = await create_recurring_transaction(
session,
test_workspace.id, test_user.id,
RecurringTransactionCreate(
description="Old",
amount=Decimal("100"),
type="debit",
frequency="monthly",
start_date=date(2025, 1, 1),
account_id=test_account_for_recurring.id,
),
)
updated = await update_recurring_transaction(
session,
rec.id,
test_workspace.id,
RecurringTransactionUpdate(description="Updated", amount=Decimal("150")),
)
assert updated is not None
assert updated.description == "Updated"
assert updated.amount == Decimal("150")
assert updated.next_occurrence == date(2025, 1, 1)
async def _monthly_rule(
session, test_workspace, test_user, account,
start_date: date = date(2026, 1, 5), day_of_month: int | None = None,
):
return await create_recurring_transaction(
session, test_workspace.id, test_user.id,
RecurringTransactionCreate(
description="Rule",
amount=Decimal("100"),
type="debit",
frequency="monthly",
start_date=start_date,
day_of_month=day_of_month,
account_id=account.id,
),
)
@pytest.mark.asyncio
async def test_update_later_start_date_defers_next_occurrence(
session: AsyncSession, test_user, test_workspace, test_account_for_recurring
):
rec = await _monthly_rule(
session, test_workspace, test_user, test_account_for_recurring,
start_date=date(2026, 8, 31), day_of_month=31,
)
rec.next_occurrence = date(2026, 9, 30)
await session.commit()
updated = await update_recurring_transaction(
session, rec.id, test_workspace.id,
RecurringTransactionUpdate(start_date=date(2026, 10, 22), day_of_month=22),
)
assert updated is not None
assert updated.next_occurrence == date(2026, 10, 22)
@pytest.mark.asyncio
async def test_update_day_of_month_keeps_pointer_ahead_of_processed_periods(
session: AsyncSession, test_user, test_workspace, test_account_for_recurring
):
# September's occurrence on the 5th was already generated.
rec = await _monthly_rule(
session, test_workspace, test_user, test_account_for_recurring, day_of_month=5,
)
rec.next_occurrence = date(2026, 10, 5)
await session.commit()
updated = await update_recurring_transaction(
session, rec.id, test_workspace.id, RecurringTransactionUpdate(day_of_month=25),
)
assert updated is not None
assert updated.next_occurrence == date(2026, 10, 25)
@pytest.mark.asyncio
async def test_update_frequency_realigns_next_occurrence(
session: AsyncSession, test_user, test_workspace, test_account_for_recurring
):
rec = await _monthly_rule(
session, test_workspace, test_user, test_account_for_recurring,
start_date=date(2026, 1, 1),
)
rec.next_occurrence = date(2026, 3, 1)
await session.commit()
updated = await update_recurring_transaction(
session, rec.id, test_workspace.id, RecurringTransactionUpdate(frequency="weekly"),
)
assert updated is not None
assert updated.next_occurrence == date(2026, 3, 5)
@pytest.mark.asyncio
@pytest.mark.parametrize("field", ["start_date", "frequency"])
async def test_update_rejects_null_schedule_field(
session: AsyncSession, test_user, test_workspace, test_account_for_recurring, field
):
rec = await _monthly_rule(session, test_workspace, test_user, test_account_for_recurring)
with pytest.raises(ValueError, match=f"{field} is required"):
await update_recurring_transaction(
session, rec.id, test_workspace.id, RecurringTransactionUpdate(**{field: None}),
)
@pytest.mark.parametrize("day", [0, -1, 32])
def test_schemas_reject_day_of_month_outside_calendar(day):
with pytest.raises(ValidationError):
RecurringTransactionUpdate(day_of_month=day)
with pytest.raises(ValidationError):
RecurringTransactionCreate(
description="Rule", amount=Decimal("1"), type="debit", frequency="monthly",
start_date=date(2026, 1, 1), account_id=uuid.uuid4(), day_of_month=day,
)
def test_update_rejects_unsupported_frequency():
# An unknown cadence would reach _advance_date's monthly fallback and
# silently turn the rule monthly when the pointer is recomputed.
with pytest.raises(ValidationError):
RecurringTransactionUpdate(frequency="daily") # ty: ignore[invalid-argument-type]
@pytest.mark.asyncio
async def test_update_resending_schedule_keeps_next_occurrence(
session: AsyncSession, test_user, test_workspace, test_account_for_recurring
):
rec = await _monthly_rule(
session, test_workspace, test_user, test_account_for_recurring, day_of_month=5,
)
rec.next_occurrence = date(2026, 10, 5)
await session.commit()
updated = await update_recurring_transaction(
session, rec.id, test_workspace.id,
RecurringTransactionUpdate(
start_date=date(2026, 1, 5), day_of_month=5, frequency="monthly",
description="Renamed",
),
)
assert updated is not None
assert updated.next_occurrence == date(2026, 10, 5)
@pytest.mark.asyncio
async def test_update_recurring_not_found(session: AsyncSession, test_user, test_workspace):
result = await update_recurring_transaction(
session,
uuid.uuid4(),
test_workspace.id,
RecurringTransactionUpdate(description="Nope"),
)
assert result is None
@pytest.mark.asyncio
async def test_delete_recurring_transaction(
session: AsyncSession, test_user, test_workspace, test_account_for_recurring
):
rec = await create_recurring_transaction(
session,
test_workspace.id, test_user.id,
RecurringTransactionCreate(
description="ToDelete",
amount=Decimal("10"),
type="debit",
frequency="monthly",
start_date=date(2025, 1, 1),
account_id=test_account_for_recurring.id,
),
)
assert await delete_recurring_transaction(session, rec.id, test_workspace.id) is True
assert await get_recurring_transaction(session, rec.id, test_workspace.id) is None
@pytest.mark.asyncio
async def test_delete_recurring_not_found(session: AsyncSession, test_user, test_workspace):
assert await delete_recurring_transaction(session, uuid.uuid4(), test_workspace.id) is False
# ---------------------------------------------------------------------------
# _advance_date
# ---------------------------------------------------------------------------
def test_advance_date_monthly():
assert _advance_date(date(2025, 1, 15), "monthly") == date(2025, 2, 15)
assert _advance_date(date(2025, 12, 10), "monthly") == date(2026, 1, 10)
def test_advance_date_monthly_overflow():
# Jan 31 -> Feb should clamp to 28
assert _advance_date(date(2025, 1, 31), "monthly") == date(2025, 2, 28)
# Leap year: Jan 31 -> Feb 29
assert _advance_date(date(2024, 1, 31), "monthly") == date(2024, 2, 29)
def test_advance_date_weekly():
assert _advance_date(date(2025, 1, 1), "weekly") == date(2025, 1, 8)
assert _advance_date(date(2025, 12, 29), "weekly") == date(2026, 1, 5)
def test_advance_date_biweekly():
assert _advance_date(date(2026, 1, 5), "biweekly") == date(2026, 1, 19)
assert _advance_date(date(2026, 12, 28), "biweekly") == date(2027, 1, 11)
def test_advance_date_yearly():
assert _advance_date(date(2025, 3, 15), "yearly") == date(2026, 3, 15)
# Leap year: Feb 29 -> Feb 28 next year
assert _advance_date(date(2024, 2, 29), "yearly") == date(2025, 2, 28)
def test_advance_date_monthly_intended_day_recovers_after_february():
# After Jan 31 clamps to Feb 28, advancing again must hit Mar 31 — not drift to Mar 28.
feb = _advance_date(date(2026, 1, 31), "monthly", intended_day=31)
assert feb == date(2026, 2, 28)
mar = _advance_date(feb, "monthly", intended_day=31)
assert mar == date(2026, 3, 31)
apr = _advance_date(mar, "monthly", intended_day=31)
assert apr == date(2026, 4, 30) # April has 30 days
may = _advance_date(apr, "monthly", intended_day=31)
assert may == date(2026, 5, 31)
def test_advance_date_monthly_intended_day_30():
# Day 30 pattern: Jan 30 -> Feb 28 -> Mar 30 (not Mar 28).
feb = _advance_date(date(2026, 1, 30), "monthly", intended_day=30)
assert feb == date(2026, 2, 28)
mar = _advance_date(feb, "monthly", intended_day=30)
assert mar == date(2026, 3, 30)
def test_advance_date_yearly_intended_day_leap_recovery():
# Feb 29 on a leap year should recover to Feb 29 four years later, not stick at 28.
y1 = _advance_date(date(2024, 2, 29), "yearly", intended_day=29)
assert y1 == date(2025, 2, 28)
y2 = _advance_date(y1, "yearly", intended_day=29)
assert y2 == date(2026, 2, 28)
y3 = _advance_date(y2, "yearly", intended_day=29)
assert y3 == date(2027, 2, 28)
y4 = _advance_date(y3, "yearly", intended_day=29)
assert y4 == date(2028, 2, 29)
def test_advance_date_quarterly():
assert _advance_date(date(2026, 1, 15), "quarterly") == date(2026, 4, 15)
assert _advance_date(date(2026, 11, 15), "quarterly") == date(2027, 2, 15)
def test_advance_date_quarterly_intended_day_recovers_after_clamping():
april = _advance_date(date(2026, 1, 31), "quarterly", intended_day=31)
assert april == date(2026, 4, 30)
july = _advance_date(april, "quarterly", intended_day=31)
assert july == date(2026, 7, 31)
october = _advance_date(july, "quarterly", intended_day=31)
assert october == date(2026, 10, 31)
january = _advance_date(october, "quarterly", intended_day=31)
assert january == date(2027, 1, 31)
def test_advance_date_quarterly_leap_year_clamping_recovers():
february = _advance_date(date(2023, 11, 30), "quarterly", intended_day=30)
assert february == date(2024, 2, 29)
may = _advance_date(february, "quarterly", intended_day=30)
assert may == date(2024, 5, 30)
def test_advance_date_semiannual_preserves_intended_day():
july = _advance_date(date(2026, 1, 31), "semiannual", intended_day=31)
assert july == date(2026, 7, 31)
january = _advance_date(july, "semiannual", intended_day=31)
assert january == date(2027, 1, 31)
february = _advance_date(date(2024, 8, 31), "semiannual", intended_day=31)
assert february == date(2025, 2, 28)
august = _advance_date(february, "semiannual", intended_day=31)
assert august == date(2025, 8, 31)
@pytest.mark.parametrize(
("nominal", "policy", "expected"),
[
(date(2026, 8, 1), "none", date(2026, 8, 1)),
(date(2026, 8, 1), "previous_friday", date(2026, 7, 31)),
(date(2026, 8, 1), "next_monday", date(2026, 8, 3)),
(date(2026, 8, 2), "none", date(2026, 8, 2)),
(date(2026, 8, 2), "previous_friday", date(2026, 7, 31)),
(date(2026, 8, 2), "next_monday", date(2026, 8, 3)),
(date(2026, 8, 3), "none", date(2026, 8, 3)),
(date(2026, 8, 3), "previous_friday", date(2026, 8, 3)),
(date(2026, 8, 3), "next_monday", date(2026, 8, 3)),
(date(2026, 8, 7), "none", date(2026, 8, 7)),
(date(2026, 8, 7), "previous_friday", date(2026, 8, 7)),
(date(2026, 8, 7), "next_monday", date(2026, 8, 7)),
],
)
def test_adjust_weekend_date(nominal, policy, expected):
assert adjust_weekend_date(nominal, policy) == expected
def test_adjust_weekend_date_rejects_unsupported_policy_on_weekday():
with pytest.raises(
ValueError, match="Unsupported weekend adjustment: nearest_weekday"
):
adjust_weekend_date(date(2026, 8, 3), "nearest_weekday")
@pytest.mark.parametrize(
("frequency", "start", "intended_day", "expected"),
[
(
"weekly",
date(2026, 8, 1),
1,
[
(date(2026, 8, 1), date(2026, 7, 31)),
(date(2026, 8, 8), date(2026, 8, 7)),
(date(2026, 8, 15), date(2026, 8, 14)),
],
),
(
"monthly",
date(2026, 1, 31),
31,
[
(date(2026, 1, 31), date(2026, 1, 30)),
(date(2026, 2, 28), date(2026, 2, 27)),
(date(2026, 3, 31), date(2026, 3, 31)),
],
),
(
"quarterly",
date(2026, 1, 31),
31,
[
(date(2026, 1, 31), date(2026, 1, 30)),
(date(2026, 4, 30), date(2026, 4, 30)),
(date(2026, 7, 31), date(2026, 7, 31)),
],
),
(
"yearly",
date(2024, 2, 29),
29,
[
(date(2024, 2, 29), date(2024, 2, 29)),
(date(2025, 2, 28), date(2025, 2, 28)),
(date(2026, 2, 28), date(2026, 2, 27)),
],
),
(
"biweekly",
date(2026, 8, 1),
1,
[
(date(2026, 8, 1), date(2026, 7, 31)),
(date(2026, 8, 15), date(2026, 8, 14)),
(date(2026, 8, 29), date(2026, 8, 28)),
],
),
(
"semiannual",
date(2024, 8, 31),
31,
[
(date(2024, 8, 31), date(2024, 8, 30)),
(date(2025, 2, 28), date(2025, 2, 28)),
(date(2025, 8, 31), date(2025, 8, 29)),
],
),
],
)
def test_weekend_adjustment_never_changes_nominal_cadence(
frequency, start, intended_day, expected
):
current = start
actual = []
for _ in expected:
actual.append((current, adjust_weekend_date(current, "previous_friday")))
current = _advance_date(current, frequency, intended_day=intended_day)
assert actual == expected
def test_occurrence_range_uses_effective_date_across_month_boundary():
july = get_occurrences_in_range(
start=date(2026, 8, 1),
frequency="monthly",
end_date=None,
range_start=date(2026, 7, 1),
range_end=date(2026, 8, 1),
weekend_adjustment="previous_friday",
)
august = get_occurrences_in_range(
start=date(2026, 8, 1),
frequency="monthly",
end_date=None,
range_start=date(2026, 8, 1),
range_end=date(2026, 9, 1),
weekend_adjustment="previous_friday",
)
assert july == [date(2026, 7, 31)]
assert august == []
assert july.count(date(2026, 7, 31)) + august.count(date(2026, 7, 31)) == 1
def test_occurrence_range_moves_sunday_to_following_monday():
assert get_occurrences_in_range(
start=date(2026, 8, 2),
frequency="monthly",
end_date=None,
range_start=date(2026, 8, 1),
range_end=date(2026, 9, 1),
weekend_adjustment="next_monday",
) == [date(2026, 8, 3)]
# ---------------------------------------------------------------------------
# get_occurrences_in_range
# ---------------------------------------------------------------------------
def test_get_occurrences_in_range_monthly():
occurrences = get_occurrences_in_range(
start=date(2025, 1, 1),
frequency="monthly",
end_date=None,
range_start=date(2025, 3, 1),
range_end=date(2025, 6, 1),
)
assert occurrences == [date(2025, 3, 1), date(2025, 4, 1), date(2025, 5, 1)]
def test_get_occurrences_in_range_respects_end_date():
occurrences = get_occurrences_in_range(
start=date(2025, 1, 1),
frequency="monthly",
end_date=date(2025, 4, 15),
range_start=date(2025, 3, 1),
range_end=date(2025, 12, 1),
)
assert occurrences == [date(2025, 3, 1), date(2025, 4, 1)]
def test_get_occurrences_in_range_weekly():
occurrences = get_occurrences_in_range(
start=date(2025, 1, 6),
frequency="weekly",
end_date=None,
range_start=date(2025, 1, 6),
range_end=date(2025, 1, 27),
)
assert len(occurrences) == 3 # Jan 6, 13, 20 (range_end is exclusive)
def test_get_occurrences_in_range_empty():
occurrences = get_occurrences_in_range(
start=date(2025, 6, 1),
frequency="monthly",
end_date=None,
range_start=date(2025, 1, 1),
range_end=date(2025, 3, 1),
)
assert occurrences == []
def test_get_occurrences_in_range_monthly_day_31_does_not_drift():
# Regression test for #67: after Feb clamps to 28, subsequent months must
# recover to their true month-end (31 / 30 / 31 / 30) instead of sticking at 28.
occurrences = get_occurrences_in_range(
start=date(2026, 1, 31),
frequency="monthly",
end_date=None,
range_start=date(2026, 1, 1),
range_end=date(2026, 7, 1),
intended_day=31,
)
assert occurrences == [
date(2026, 1, 31),
date(2026, 2, 28),
date(2026, 3, 31),
date(2026, 4, 30),
date(2026, 5, 31),
date(2026, 6, 30),
]
def test_get_occurrences_in_range_monthly_day_30_does_not_drift():
occurrences = get_occurrences_in_range(
start=date(2026, 1, 30),
frequency="monthly",
end_date=None,
range_start=date(2026, 1, 1),
range_end=date(2026, 7, 1),
intended_day=30,
)
assert occurrences == [
date(2026, 1, 30),
date(2026, 2, 28),
date(2026, 3, 30),
date(2026, 4, 30),
date(2026, 5, 30),
date(2026, 6, 30),
]
def test_get_occurrences_in_range_monthly_day_29_does_not_drift():
occurrences = get_occurrences_in_range(
start=date(2026, 1, 29),
frequency="monthly",
end_date=None,
range_start=date(2026, 1, 1),
range_end=date(2026, 7, 1),
intended_day=29,
)
assert occurrences == [
date(2026, 1, 29),
date(2026, 2, 28),
date(2026, 3, 29),
date(2026, 4, 29),
date(2026, 5, 29),
date(2026, 6, 29),
]
def test_get_occurrences_in_range_quarterly():
occurrences = get_occurrences_in_range(
start=date(2026, 1, 31),
frequency="quarterly",
end_date=None,
range_start=date(2026, 1, 1),
range_end=date(2027, 2, 1),
intended_day=31,
)
assert occurrences == [
date(2026, 1, 31),
date(2026, 4, 30),
date(2026, 7, 31),
date(2026, 10, 31),
date(2027, 1, 31),
]
def test_get_occurrences_in_range_quarterly_respects_end_date():
occurrences = get_occurrences_in_range(
start=date(2026, 1, 15),
frequency="quarterly",
end_date=date(2026, 7, 1),
range_start=date(2026, 1, 1),
range_end=date(2027, 1, 1),
)
assert occurrences == [date(2026, 1, 15), date(2026, 4, 15)]
@pytest.mark.parametrize(
("frequency", "start", "range_start", "range_end", "intended_day", "expected"),
[
(
"biweekly",
date(2026, 1, 5),
date(2026, 1, 1),
date(2026, 2, 10),
None,
[date(2026, 1, 5), date(2026, 1, 19), date(2026, 2, 2)],
),
(
"semiannual",
date(2024, 8, 31),
date(2024, 8, 1),
date(2025, 9, 1),
31,
[date(2024, 8, 31), date(2025, 2, 28), date(2025, 8, 31)],
),
],
ids=["biweekly", "semiannual"],
)
def test_get_occurrences_in_range_new_frequencies(
frequency, start, range_start, range_end, intended_day, expected
):
assert get_occurrences_in_range(
start=start,
frequency=frequency,
end_date=None,
range_start=range_start,
range_end=range_end,
intended_day=intended_day,
) == expected
# ---------------------------------------------------------------------------
# generate_pending
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_generate_pending(session: AsyncSession, test_user, test_workspace, test_account_for_recurring):
rec = await create_recurring_transaction(
session,
test_workspace.id, test_user.id,
RecurringTransactionCreate(
description="Monthly Sub",
amount=Decimal("29.90"),
type="debit",
frequency="monthly",
start_date=date(2025, 1, 1),
account_id=test_account_for_recurring.id,
),
)
count = await generate_pending(session, test_user.id, up_to=date(2025, 3, 15))
assert count == 3 # Jan, Feb, Mar
# Verify transactions were created
result = await session.execute(
select(Transaction).where(
Transaction.user_id == test_user.id,
Transaction.source == "recurring",
Transaction.description == "Monthly Sub",
)
)
txns = result.scalars().all()
assert len(txns) == 3
# Only occurrences that already came due are materialized, so they are
# actuals. Marking them pending would keep them out of every current
# figure with no way back on an account that never syncs.
assert {tx.status for tx in txns} == {"posted"}
# next_occurrence should be advanced past cutoff
await session.refresh(rec)
assert rec.next_occurrence == date(2025, 4, 1)
@pytest.mark.asyncio
async def test_generate_pending_holds_synced_account_rows_pending(
session: AsyncSession, test_user, test_workspace, test_connection
):
"""On a synced account the placeholder waits for the real charge.
The incoming charge often fails to match, and two posted rows for one
charge inflate the balance silently. Holding it pending makes a missed
match cost a visible stale row instead of a wrong number.
"""
synced = Account(
id=uuid.uuid4(),
user_id=test_user.id,
workspace_id=test_workspace.id,
name="Synced",
type="checking",
balance=Decimal("0"),
currency="BRL",
connection_id=test_connection.id,
)
session.add(synced)
await session.commit()
await create_recurring_transaction(
session,
test_workspace.id, test_user.id,
RecurringTransactionCreate(
description="Synced Sub",
amount=Decimal("10"),
type="debit",
frequency="monthly",
start_date=date(2025, 1, 1),
account_id=synced.id,
),
)
assert await generate_pending(session, test_user.id, up_to=date(2025, 1, 1)) == 1
result = await session.execute(
select(Transaction).where(Transaction.account_id == synced.id)
)
[txn] = result.scalars().all()
assert txn.status == "pending"
@pytest.mark.asyncio
async def test_generate_pending_quarterly_respects_end_date(
session: AsyncSession, test_user, test_workspace, test_account_for_recurring
):
rec = await create_recurring_transaction(
session,
test_workspace.id,
test_user.id,
RecurringTransactionCreate(
description="Quarterly Insurance",
amount=Decimal("300"),
type="debit",
frequency="quarterly",
day_of_month=30,
start_date=date(2023, 11, 30),
end_date=date(2024, 5, 30),
account_id=test_account_for_recurring.id,
),
)
count = await generate_pending(session, test_user.id, up_to=date(2024, 12, 31))
assert count == 3
result = await session.execute(
select(Transaction)
.where(
Transaction.recurring_transaction_id == rec.id,
Transaction.source == "recurring",
)
.order_by(Transaction.date)
)
assert [transaction.date for transaction in result.scalars()] == [
date(2023, 11, 30),
date(2024, 2, 29),
date(2024, 5, 30),
]
await session.refresh(rec)
assert rec.next_occurrence == date(2024, 8, 30)
assert rec.is_active is False
@pytest.mark.asyncio
@pytest.mark.parametrize(
(
"frequency",
"start",
"up_to",
"day_of_month",
"expected_dates",
"expected_next",
),
[
(
"biweekly",
date(2026, 1, 5),
date(2026, 1, 19),
None,
[date(2026, 1, 5), date(2026, 1, 19)],
date(2026, 2, 2),
),
(
"semiannual",
date(2024, 8, 31),
date(2025, 2, 28),
31,
[date(2024, 8, 31), date(2025, 2, 28)],
date(2025, 8, 31),
),
],
ids=["biweekly", "semiannual"],
)
async def test_generate_pending_new_frequencies(
session: AsyncSession,
test_user,
test_workspace,
test_account_for_recurring,
frequency,
start,
up_to,
day_of_month,
expected_dates,
expected_next,
):
recurring = await create_recurring_transaction(
session,
test_workspace.id,
test_user.id,
RecurringTransactionCreate(
description=f"{frequency} regression",
amount=Decimal("25"),
type="debit",
frequency=frequency,
day_of_month=day_of_month,
start_date=start,
account_id=test_account_for_recurring.id,
),
)
await generate_pending(session, test_user.id, up_to=up_to)
result = await session.execute(
select(Transaction)
.where(Transaction.recurring_transaction_id == recurring.id)
.order_by(Transaction.date)
)
actual_dates = [transaction.date for transaction in result.scalars()]
await session.refresh(recurring)
assert (actual_dates, recurring.next_occurrence) == (expected_dates, expected_next)
@pytest.mark.asyncio
async def test_generate_pending_deactivates_past_end_date(
session: AsyncSession, test_user, test_workspace, test_account_for_recurring
):
rec = await create_recurring_transaction(
session,
test_workspace.id, test_user.id,
RecurringTransactionCreate(
description="Short Sub",
amount=Decimal("10"),
type="debit",
frequency="monthly",
start_date=date(2025, 1, 1),
end_date=date(2025, 2, 15),
account_id=test_account_for_recurring.id,
),
)
count = await generate_pending(session, test_user.id, up_to=date(2025, 12, 31))
# Should create Jan and Feb (Feb 1 <= Feb 15), then deactivate
assert count == 2
await session.refresh(rec)
assert rec.is_active is False
@pytest.mark.asyncio
async def test_generate_pending_no_duplicates(
session: AsyncSession, test_user, test_workspace, test_account_for_recurring
):
await create_recurring_transaction(
session,
test_workspace.id, test_user.id,
RecurringTransactionCreate(
description="NoDup",
amount=Decimal("5"),
type="debit",
frequency="monthly",
start_date=date(2025, 1, 1),
account_id=test_account_for_recurring.id,
),
)
# Generate once
count1 = await generate_pending(session, test_user.id, up_to=date(2025, 3, 1))
# Generate again with same cutoff — should produce 0
count2 = await generate_pending(session, test_user.id, up_to=date(2025, 3, 1))
assert count1 == 3
assert count2 == 0
@pytest.mark.asyncio
async def test_generate_pending_previous_friday_uses_effective_cutoff_and_date(
session: AsyncSession, test_user, test_workspace, test_account_for_recurring
):
rec = await create_recurring_transaction(
session,
test_workspace.id,
test_user.id,
RecurringTransactionCreate(
description="Weekend rent",
amount=Decimal("1000"),
type="debit",
frequency="monthly",
start_date=date(2026, 8, 1),
weekend_adjustment="previous_friday",
account_id=test_account_for_recurring.id,
),
)
assert await generate_pending(session, test_user.id, up_to=date(2026, 7, 31)) == 1
transaction = (
await session.execute(
select(Transaction).where(Transaction.recurring_transaction_id == rec.id)
)
).scalar_one()
assert transaction.date == date(2026, 7, 31)
await session.refresh(rec)
assert rec.next_occurrence == date(2026, 9, 1)
@pytest.mark.asyncio
async def test_generate_pending_next_monday_waits_until_effective_date(
session: AsyncSession, test_user, test_workspace, test_account_for_recurring
):
rec = await create_recurring_transaction(
session,
test_workspace.id,
test_user.id,
RecurringTransactionCreate(
description="Weekend salary",
amount=Decimal("2000"),
type="credit",
frequency="monthly",
start_date=date(2026, 8, 2),
weekend_adjustment="next_monday",
account_id=test_account_for_recurring.id,
),
)
assert await generate_pending(session, test_user.id, up_to=date(2026, 8, 2)) == 0
await session.refresh(rec)
assert rec.next_occurrence == date(2026, 8, 2)
assert await generate_pending(session, test_user.id, up_to=date(2026, 8, 3)) == 1
transaction = (
await session.execute(
select(Transaction).where(Transaction.recurring_transaction_id == rec.id)
)
).scalar_one()
assert transaction.date == date(2026, 8, 3)
await session.refresh(rec)
assert rec.next_occurrence == date(2026, 9, 2)
@pytest.mark.asyncio
async def test_generate_pending_weekend_adjustment_respects_nominal_end_date(
session: AsyncSession, test_user, test_workspace, test_account_for_recurring
):
rec = await create_recurring_transaction(
session,
test_workspace.id,
test_user.id,
RecurringTransactionCreate(
description="Final weekend bill",
amount=Decimal("50"),
type="debit",
frequency="monthly",
start_date=date(2026, 8, 1),
end_date=date(2026, 8, 1),
weekend_adjustment="previous_friday",
account_id=test_account_for_recurring.id,
),
)
assert await generate_pending(session, test_user.id, up_to=date(2026, 7, 31)) == 1
assert await generate_pending(session, test_user.id, up_to=date(2026, 12, 31)) == 0
result = await session.execute(
select(Transaction).where(Transaction.recurring_transaction_id == rec.id)
)
assert [transaction.date for transaction in result.scalars()] == [date(2026, 7, 31)]
await session.refresh(rec)
assert rec.next_occurrence == date(2026, 9, 1)
assert rec.is_active is False