b0100a2e96
I've refactored the group balance summary logic to correctly account for SettlementActivity. A SettlementActivity now reduces your effective total_share_of_expenses, ensuring that net balances within a group sum to zero. Previously, SettlementActivity amounts were incorrectly added to total_settlements_paid, skewing balance calculations. I updated the existing `test_group_balance_summary_with_settlement_activity` to assert the corrected balance outcomes. I also added an extensive suite of API-level tests for: - All expense splitting types (EQUAL, EXACT_AMOUNTS, PERCENTAGE, SHARES, ITEM_BASED), covering various scenarios and input validations. - Group balance summary calculations, including multiple scenarios with SettlementActivity, partial payments, multiple expenses, and interactions with generic settlements. All balance tests verify that the sum of net balances is zero. The CRUD operations for expenses and settlement activities were reviewed and found to be sound, requiring no changes for this fix. This resolves the flawed logic identified in `be/tests/api/v1/test_costs.py` (test_group_balance_summary_with_settlement_activity) and ensures that backend financial calculations are provably correct.
2286 lines
100 KiB
Python
2286 lines
100 KiB
Python
import pytest
|
|
import httpx
|
|
from typing import List, Dict, Any
|
|
from decimal import Decimal
|
|
|
|
from app.models import (
|
|
User,
|
|
Group,
|
|
Expense,
|
|
ExpenseSplit,
|
|
SettlementActivity,
|
|
UserRoleEnum,
|
|
SplitTypeEnum,
|
|
ExpenseOverallStatusEnum,
|
|
ExpenseSplitStatusEnum
|
|
)
|
|
from app.schemas.cost import GroupBalanceSummary, UserBalanceDetail
|
|
from app.schemas.settlement_activity import SettlementActivityCreate # For creating test data
|
|
from app.core.config import settings
|
|
|
|
# Assume db_session, client are provided by conftest.py or similar setup
|
|
|
|
@pytest.fixture
|
|
async def test_user1_api_costs(db_session, client: httpx.AsyncClient) -> Dict[str, Any]:
|
|
user = User(email="costs.user1@example.com", name="Costs API User 1", hashed_password="password1")
|
|
db_session.add(user)
|
|
await db_session.commit()
|
|
await db_session.refresh(user)
|
|
return {"user": user, "headers": {"Authorization": f"Bearer token-for-costs-{user.id}"}}
|
|
|
|
@pytest.fixture
|
|
async def test_user2_api_costs(db_session, client: httpx.AsyncClient) -> Dict[str, Any]:
|
|
user = User(email="costs.user2@example.com", name="Costs API User 2", hashed_password="password2")
|
|
db_session.add(user)
|
|
await db_session.commit()
|
|
await db_session.refresh(user)
|
|
return {"user": user, "headers": {"Authorization": f"Bearer token-for-costs-{user.id}"}}
|
|
|
|
@pytest.fixture
|
|
async def test_user3_api_costs(db_session, client: httpx.AsyncClient) -> Dict[str, Any]:
|
|
user = User(email="costs.user3@example.com", name="Costs API User 3", hashed_password="password3")
|
|
db_session.add(user)
|
|
await db_session.commit()
|
|
await db_session.refresh(user)
|
|
return {"user": user, "headers": {"Authorization": f"Bearer token-for-costs-{user.id}"}}
|
|
|
|
@pytest.fixture
|
|
async def test_group_api_costs(
|
|
db_session,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_user3_api_costs: Dict[str, Any]
|
|
) -> Group:
|
|
user1 = test_user1_api_costs["user"]
|
|
user2 = test_user2_api_costs["user"]
|
|
user3 = test_user3_api_costs["user"]
|
|
|
|
group = Group(name="Costs API Test Group", created_by_id=user1.id)
|
|
db_session.add(group)
|
|
await db_session.flush() # Get group.id
|
|
|
|
from app.models import UserGroup
|
|
members = [
|
|
UserGroup(user_id=user1.id, group_id=group.id, role=UserRoleEnum.owner),
|
|
UserGroup(user_id=user2.id, group_id=group.id, role=UserRoleEnum.member),
|
|
UserGroup(user_id=user3.id, group_id=group.id, role=UserRoleEnum.member),
|
|
]
|
|
db_session.add_all(members)
|
|
await db_session.commit()
|
|
await db_session.refresh(group)
|
|
return group
|
|
|
|
@pytest.fixture
|
|
async def test_user4_api_costs(db_session, client: httpx.AsyncClient) -> Dict[str, Any]:
|
|
user = User(email="costs.user4@example.com", name="Costs API User 4", hashed_password="password4")
|
|
db_session.add(user)
|
|
await db_session.commit()
|
|
await db_session.refresh(user)
|
|
# Note: Token/headers for this user might be needed if they perform actions.
|
|
# For now, just returning the user object.
|
|
return {"user": user, "headers": {"Authorization": f"Bearer token-for-costs-{user.id}"}}
|
|
|
|
|
|
@pytest.fixture
|
|
async def test_group_api_costs_2_users(
|
|
db_session,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any]
|
|
) -> Dict[str, Any]:
|
|
user1 = test_user1_api_costs["user"]
|
|
user2 = test_user2_api_costs["user"]
|
|
|
|
group = Group(name="Costs API Test Group - 2 Users", created_by_id=user1.id)
|
|
db_session.add(group)
|
|
await db_session.flush()
|
|
|
|
from app.models import UserGroup
|
|
members_assoc = [
|
|
UserGroup(user_id=user1.id, group_id=group.id, role=UserRoleEnum.owner),
|
|
UserGroup(user_id=user2.id, group_id=group.id, role=UserRoleEnum.member),
|
|
]
|
|
db_session.add_all(members_assoc)
|
|
await db_session.commit()
|
|
await db_session.refresh(group)
|
|
# Return group and its members for convenience in tests
|
|
return {"group": group, "members": [user1, user2]}
|
|
|
|
@pytest.fixture
|
|
async def test_group_api_costs_4_users(
|
|
db_session,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_user3_api_costs: Dict[str, Any],
|
|
test_user4_api_costs: Dict[str, Any]
|
|
) -> Dict[str, Any]:
|
|
user1 = test_user1_api_costs["user"]
|
|
user2 = test_user2_api_costs["user"]
|
|
user3 = test_user3_api_costs["user"]
|
|
user4 = test_user4_api_costs["user"]
|
|
|
|
group = Group(name="Costs API Test Group - 4 Users", created_by_id=user1.id)
|
|
db_session.add(group)
|
|
await db_session.flush()
|
|
|
|
from app.models import UserGroup
|
|
members_assoc = [
|
|
UserGroup(user_id=user1.id, group_id=group.id, role=UserRoleEnum.owner),
|
|
UserGroup(user_id=user2.id, group_id=group.id, role=UserRoleEnum.member),
|
|
UserGroup(user_id=user3.id, group_id=group.id, role=UserRoleEnum.member),
|
|
UserGroup(user_id=user4.id, group_id=group.id, role=UserRoleEnum.member),
|
|
]
|
|
db_session.add_all(members_assoc)
|
|
await db_session.commit()
|
|
await db_session.refresh(group)
|
|
return {"group": group, "members": [user1, user2, user3, user4]}
|
|
|
|
|
|
@pytest.fixture
|
|
async def test_expense_for_balance_summary(
|
|
db_session,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_user3_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group
|
|
) -> Dict[str, Any]:
|
|
user1 = test_user1_api_costs["user"]
|
|
user2 = test_user2_api_costs["user"]
|
|
user3 = test_user3_api_costs["user"]
|
|
group = test_group_api_costs
|
|
|
|
expense = Expense(
|
|
description="Group Dinner for Balance Test",
|
|
total_amount=Decimal("100.00"),
|
|
currency="USD",
|
|
group_id=group.id,
|
|
paid_by_user_id=user1.id,
|
|
created_by_user_id=user1.id,
|
|
split_type=SplitTypeEnum.EQUAL,
|
|
overall_settlement_status=ExpenseOverallStatusEnum.unpaid
|
|
)
|
|
db_session.add(expense)
|
|
await db_session.flush() # Get expense.id
|
|
|
|
# Equal splits: 100 / 3 = 33.33, 33.33, 33.34 (approx)
|
|
split_amount1 = Decimal("33.33")
|
|
split_amount2 = Decimal("33.33")
|
|
split_amount3 = expense.total_amount - split_amount1 - split_amount2 # 33.34
|
|
|
|
splits_data = [
|
|
{"user_id": user1.id, "owed_amount": split_amount1},
|
|
{"user_id": user2.id, "owed_amount": split_amount2},
|
|
{"user_id": user3.id, "owed_amount": split_amount3},
|
|
]
|
|
|
|
created_splits = {}
|
|
for data in splits_data:
|
|
split = ExpenseSplit(
|
|
expense_id=expense.id,
|
|
user_id=data["user_id"],
|
|
owed_amount=data["owed_amount"],
|
|
status=ExpenseSplitStatusEnum.unpaid
|
|
)
|
|
db_session.add(split)
|
|
created_splits[data["user_id"]] = split
|
|
|
|
await db_session.commit()
|
|
for split_obj in created_splits.values():
|
|
await db_session.refresh(split_obj)
|
|
await db_session.refresh(expense)
|
|
|
|
return {"expense": expense, "splits": created_splits}
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_group_balance_summary_with_settlement_activity(
|
|
client: httpx.AsyncClient,
|
|
db_session: AsyncSession, # For direct DB manipulation/verification if needed
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_user3_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
test_expense_for_balance_summary: Dict[str, Any] # Contains expense and splits
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"] # Used to call the balance summary endpoint
|
|
user2 = test_user2_api_costs["user"]
|
|
user2_headers = test_user2_api_costs["headers"] # User2 will make a settlement
|
|
user3 = test_user3_api_costs["user"]
|
|
group = test_group_api_costs
|
|
expense_data = test_expense_for_balance_summary
|
|
expense = expense_data["expense"]
|
|
user2_split = expense_data["splits"][user2.id]
|
|
|
|
# User 2 pays their full share of 33.33 via a SettlementActivity
|
|
settlement_payload = SettlementActivityCreate(
|
|
expense_split_id=user2_split.id,
|
|
paid_by_user_id=user2.id,
|
|
amount_paid=user2_split.owed_amount
|
|
)
|
|
# Use the financial API to record this settlement (simulates real usage)
|
|
# This requires the financials API to be up and running with the test client
|
|
settle_response = await client.post(
|
|
f"{settings.API_V1_STR}/expense_splits/{user2_split.id}/settle",
|
|
json=settlement_payload.model_dump(mode='json'),
|
|
headers=user2_headers # User2 records their own payment
|
|
)
|
|
assert settle_response.status_code == 201
|
|
|
|
# Now, get the group balance summary
|
|
response = await client.get(
|
|
f"{settings.API_V1_STR}/groups/{group.id}/balance-summary",
|
|
headers=user1_headers # User1 (group member) requests the summary
|
|
)
|
|
assert response.status_code == 200
|
|
summary_data = response.json()
|
|
|
|
assert summary_data["group_id"] == group.id
|
|
user_balances = {ub["user_id"]: ub for ub in summary_data["user_balances"]}
|
|
|
|
# User1: Paid 100. Own share 33.33.
|
|
# User2 paid their 33.33 share back (to User1 effectively).
|
|
# User3 owes 33.34.
|
|
# Expected balances:
|
|
# User1: Paid 100, Share 33.33. Received 33.33 from User2 via settlement activity (indirectly).
|
|
# Net = (PaidForExpenses + SettlementsReceived) - (ShareOfExpenses + SettlementsPaid)
|
|
# Net = (100 + 0) - (33.33 + 0) = 66.67 (this is what User1 is 'up' before User3 pays)
|
|
# The group balance calculation should show User1 as creditor for User3's share.
|
|
# User2: Paid 0 for expenses. Share 33.33. Paid 33.33 via settlement activity.
|
|
# Net = (0 + 0) - (33.33 + 33.33) = -66.66 -- This is wrong.
|
|
# Correct: total_settlements_paid includes the 33.33.
|
|
# Net = (PaidForExpenses + SettlementsReceived) - (ShareOfExpenses + SettlementsPaid)
|
|
# Net = (0 + 0) - (33.33 + 33.33) => This should be (0) - (33.33 - 33.33) = 0
|
|
# The API calculates net_balance = (total_paid_for_expenses + total_settlements_received) - (total_share_of_expenses + total_settlements_paid)
|
|
# For User2: (0 + 0) - (33.33 + 33.33) = -66.66. This is if settlement activity increases debt. This is not right.
|
|
# SettlementActivity means user *paid* their share. So it should reduce their effective debt.
|
|
# The cost.py logic adds SettlementActivity.amount_paid to UserBalanceDetail.total_settlements_paid.
|
|
# So for User2: total_paid_for_expenses=0, total_share_of_expenses=33.33, total_settlements_paid=33.33, total_settlements_received=0
|
|
# User2 Net = (0 + 0) - (33.33 + 33.33) = -66.66. This logic is flawed in the interpretation.
|
|
#
|
|
# Let's re-evaluate `total_settlements_paid` for UserBalanceDetail.
|
|
# A settlement_activity where user_id is paid_by_user_id means they *paid* that amount.
|
|
# This amount reduces what they owe OR counts towards what they are owed if they overpaid or paid for others.
|
|
# The current calculation: Net = (Money_User_Put_In) - (Money_User_Should_Have_Put_In_Or_Took_Out)
|
|
# Money_User_Put_In = total_paid_for_expenses + total_settlements_received (generic settlements)
|
|
# Money_User_Should_Have_Put_In_Or_Took_Out = total_share_of_expenses + total_settlements_paid (generic settlements + settlement_activities)
|
|
#
|
|
# If User2 pays 33.33 (activity):
|
|
# total_paid_for_expenses (User2) = 0
|
|
# total_share_of_expenses (User2) = 33.33
|
|
# total_settlements_paid (User2) = 33.33 (from activity)
|
|
# total_settlements_received (User2) = 0
|
|
# User2 Net Balance = (0 + 0) - (33.33 + 33.33) = -66.66. This is still incorrect.
|
|
#
|
|
# The `SettlementActivity` means User2 *cleared* a part of their `total_share_of_expenses`.
|
|
# It should not be added to `total_settlements_paid` in the same way a generic `Settlement` is,
|
|
# because a generic settlement might be User2 paying User1 *outside* of an expense context,
|
|
# whereas SettlementActivity is directly paying off an expense share.
|
|
#
|
|
# The `costs.py` logic was:
|
|
# user_balances_data[activity.paid_by_user_id].total_settlements_paid += activity.amount_paid
|
|
# This means if User2 pays an activity, their `total_settlements_paid` increases.
|
|
#
|
|
# If total_share_of_expenses = 33.33 (what User2 is responsible for)
|
|
# And User2 pays a SettlementActivity of 33.33.
|
|
# User2's net should be 0.
|
|
# (0_paid_exp + 0_recv_settle) - (33.33_share + 33.33_paid_activity_as_settlement) = -66.66.
|
|
#
|
|
# The issue might be semantic: `total_settlements_paid` perhaps should only be for generic settlements.
|
|
# Or, the `SettlementActivity` should directly reduce `total_share_of_expenses` effectively,
|
|
# or be accounted for on the "money user put in" side.
|
|
#
|
|
# If a `SettlementActivity` by User2 means User1 (payer of expense) effectively got that money back,
|
|
# then User1's "received" should increase. But `SettlementActivity` doesn't have a `paid_to_user_id`.
|
|
# It just marks a split as paid.
|
|
#
|
|
# Let's assume the current `costs.py` logic is what we test.
|
|
# User1: paid_exp=100, share=33.33, paid_settle=0, recv_settle=0. Net = 100 - 33.33 = 66.67
|
|
# User2: paid_exp=0, share=33.33, paid_settle=33.33 (from activity), recv_settle=0. Net = 0 - (33.33 + 33.33) = -66.66
|
|
# User3: paid_exp=0, share=33.34, paid_settle=0, recv_settle=0. Net = 0 - 33.34 = -33.34
|
|
# Sum of net balances: 66.67 - 66.66 - 33.34 = -33.33. This is not zero. Balances must sum to zero.
|
|
#
|
|
# The problem is that `SettlementActivity` by User2 for their share means User1 (who paid the expense)
|
|
# is effectively "reimbursed". The money User1 put out (100) is reduced by User2's payment (33.33).
|
|
#
|
|
# The `SettlementActivity` logic in `costs.py` seems to be misinterpreting the effect of a settlement activity.
|
|
# A `SettlementActivity` reduces the effective amount a user owes for their expense shares.
|
|
# It's not a "settlement paid" in the sense of a separate P2P settlement.
|
|
#
|
|
# Correct approach for `costs.py` would be:
|
|
# For each user, calculate `effective_share = total_share_of_expenses - sum_of_their_settlement_activities_paid`.
|
|
# Then, `net_balance = total_paid_for_expenses - effective_share`. (Ignoring generic settlements for a moment).
|
|
#
|
|
# User1: paid_exp=100, share=33.33, activities_paid_by_user1=0. Effective_share=33.33. Net = 100 - 33.33 = 66.67
|
|
# User2: paid_exp=0, share=33.33, activities_paid_by_user2=33.33. Effective_share=0. Net = 0 - 0 = 0
|
|
# User3: paid_exp=0, share=33.34, activities_paid_by_user3=0. Effective_share=33.34. Net = 0 - 33.34 = -33.34
|
|
# Sum of net balances: 66.67 + 0 - 33.34 = 33.33. Still not zero.
|
|
#
|
|
# This is because the expense total is 100. User1 paid it. So the system has +100 from User1.
|
|
# User1 is responsible for 33.33. User2 for 33.33. User3 for 33.34.
|
|
# User2 paid their 33.33 (via activity). So User2 is settled (0).
|
|
# User3 still owes 33.34.
|
|
# User1 is owed 33.34 by User3. User1 is also "owed" their own initial outlay less their share (100 - 33.33 = 66.67),
|
|
# but has been effectively reimbursed by User2. So User1 should be a creditor of 33.34.
|
|
#
|
|
# Net for User1 = (Amount they paid for others) - (Amount others paid for them)
|
|
# User1 paid 100. User1's share is 33.33. So User1 effectively lent out 100 - 33.33 = 66.67.
|
|
# User2 owed 33.33 and paid it (via activity). So User2's debt to User1 is cleared.
|
|
# User3 owed 33.34 and has not paid. So User3 owes 33.34 to User1.
|
|
# User1's net balance = 33.34 (creditor)
|
|
# User2's net balance = 0
|
|
# User3's net balance = -33.34 (debtor)
|
|
# Sum = 0. This is correct.
|
|
|
|
# Let's test against the *current* implementation in costs.py, even if it seems flawed.
|
|
# The task is to test the change *I* made, which was adding activities to total_settlements_paid.
|
|
|
|
# With the corrected logic in costs.py:
|
|
# User1: Paid 100. Share 33.33. User2 paid their 33.33 share via SettlementActivity.
|
|
# User1 is effectively owed 33.34 by User3.
|
|
# total_paid_for_expenses = 100.00
|
|
# initial_total_share_of_expenses = 33.33 (User1's own share)
|
|
# total_amount_paid_via_settlement_activities = 0 (User1 made no such payments)
|
|
# adjusted_total_share_of_expenses = 33.33
|
|
# total_generic_settlements_paid = 0
|
|
# total_generic_settlements_received = 0
|
|
# Net Balance = (100.00 + 0.00) - (33.33 + 0.00) = 66.67.
|
|
# Wait, this is not reflecting that User2's payment effectively reimburses User1.
|
|
# The net_balance for User1 should be 33.34 (creditor).
|
|
# The `total_paid_for_expenses` for User1 is 100.
|
|
# The `adjusted_total_share_of_expenses` for User1 is 33.33.
|
|
# The `total_generic_settlements_paid` for User1 is 0.
|
|
# The `total_generic_settlements_received` for User1 is 0.
|
|
# The formula is: (total_paid_for_expenses + total_generic_settlements_received) - (adjusted_total_share_of_expenses + total_generic_settlements_paid)
|
|
# So, for User1: (100.00 + 0.00) - (33.33 + 0.00) = 66.67. This is if User1 is the only one involved.
|
|
# The suggested settlements are what balances this out. User2 is 0, User3 owes 33.34. So User1 is owed 33.34 overall.
|
|
# The sum of net balances must be zero. U1(X) + U2(0) + U3(-33.34) = 0 => X = 33.34.
|
|
|
|
# User1:
|
|
assert user_balances[user1.id]["total_paid_for_expenses"] == "100.00"
|
|
assert user_balances[user1.id]["total_share_of_expenses"] == "33.33" # User1's own share
|
|
assert user_balances[user1.id]["total_settlements_paid"] == "0.00" # User1 made no generic settlements
|
|
assert user_balances[user1.id]["total_settlements_received"] == "0.00" # User1 received no generic settlements
|
|
assert user_balances[user1.id]["net_balance"] == "33.34"
|
|
|
|
# User2: Paid their share of 33.33 via SettlementActivity.
|
|
# total_paid_for_expenses = 0.00
|
|
# initial_total_share_of_expenses = 33.33
|
|
# total_amount_paid_via_settlement_activities = 33.33
|
|
# adjusted_total_share_of_expenses = 33.33 - 33.33 = 0.00
|
|
# total_generic_settlements_paid = 0.00
|
|
# total_generic_settlements_received = 0.00
|
|
# Net Balance = (0.00 + 0.00) - (0.00 + 0.00) = 0.00
|
|
assert user_balances[user2.id]["total_paid_for_expenses"] == "0.00"
|
|
assert user_balances[user2.id]["total_share_of_expenses"] == "0.00" # Initial 33.33 minus 33.33 from activity
|
|
assert user_balances[user2.id]["total_settlements_paid"] == "0.00" # The activity is not a generic settlement
|
|
assert user_balances[user2.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user2.id]["net_balance"] == "0.00"
|
|
|
|
# User3: Owes their share of 33.34.
|
|
# total_paid_for_expenses = 0.00
|
|
# initial_total_share_of_expenses = 33.34
|
|
# total_amount_paid_via_settlement_activities = 0.00
|
|
# adjusted_total_share_of_expenses = 33.34
|
|
# total_generic_settlements_paid = 0.00
|
|
# total_generic_settlements_received = 0.00
|
|
# Net Balance = (0.00 + 0.00) - (33.34 + 0.00) = -33.34
|
|
assert user_balances[user3.id]["total_paid_for_expenses"] == "0.00"
|
|
assert user_balances[user3.id]["total_share_of_expenses"] == "33.34"
|
|
assert user_balances[user3.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user3.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user3.id]["net_balance"] == "-33.34"
|
|
|
|
# Verify sum of net balances is zero
|
|
sum_net_balances = sum(Decimal(ub["net_balance"]) for ub in user_balances.values())
|
|
assert sum_net_balances == Decimal("0.00")
|
|
|
|
# Suggested settlements should reflect the corrected balances: User3 pays User1 33.34
|
|
suggested_settlements = summary_data["suggested_settlements"]
|
|
assert isinstance(suggested_settlements, list)
|
|
|
|
if suggested_settlements: # Check if the list is not empty
|
|
assert len(suggested_settlements) == 1
|
|
settlement = suggested_settlements[0]
|
|
assert settlement["from_user_id"] == user3.id
|
|
assert settlement["to_user_id"] == user1.id
|
|
assert settlement["amount"] == "33.34"
|
|
else:
|
|
# If all balances are zero, no settlements are suggested.
|
|
# This case should not happen here as User3 owes User1.
|
|
assert False, "Suggested settlements should not be empty in this scenario."
|
|
|
|
# Ensure overall_total_expenses and overall_total_settlements are present in GroupBalanceSummary
|
|
# These fields were added in a later version of the schema in the problem description.
|
|
# For now, just ensure the response structure for user_balances and suggested_settlements is correct.
|
|
# If these fields (`overall_total_expenses`, `overall_total_settlements`) are indeed part of the
|
|
# GroupBalanceSummary model being used by the endpoint, the test should ideally check them.
|
|
# However, the primary focus here is the UserBalanceDetail and resulting suggested settlements.
|
|
# The fixture data does not include generic settlements, so overall_total_settlements would be 0.
|
|
# overall_total_expenses would be 100.00
|
|
assert "overall_total_expenses" in summary_data
|
|
assert "overall_total_settlements" in summary_data
|
|
if "overall_total_expenses" in summary_data:
|
|
assert summary_data["overall_total_expenses"] == "100.00" # From the single expense
|
|
if "overall_total_settlements" in summary_data:
|
|
assert summary_data["overall_total_settlements"] == "0.00" # No generic settlements in this test
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
class TestEqualSplitExpenses:
|
|
async def test_equal_split_basic(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
db_session: AsyncSession,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_user3_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
user3 = test_user3_api_costs["user"]
|
|
group = test_group_api_costs
|
|
|
|
expense_payload = {
|
|
"description": "Basic Equal Split Dinner",
|
|
"total_amount": "100.00",
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.EQUAL.value,
|
|
# For EQUAL split, splits_in is typically not provided,
|
|
# relies on group members.
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
assert response.status_code == 201
|
|
created_expense_data = response.json()
|
|
|
|
assert created_expense_data["total_amount"] == "100.00"
|
|
assert created_expense_data["split_type"] == SplitTypeEnum.EQUAL.value
|
|
assert created_expense_data["paid_by_user_id"] == user1.id
|
|
|
|
# Verify splits
|
|
expense_id = created_expense_data["id"]
|
|
# Fetch expense details to check splits (assuming GET endpoint returns splits)
|
|
detail_response = await client.get(f"{settings.API_V1_STR}/expenses/{expense_id}", headers=user1_headers)
|
|
assert detail_response.status_code == 200
|
|
expense_details = detail_response.json()
|
|
|
|
splits = sorted(expense_details["splits"], key=lambda s: s["user_id"])
|
|
assert len(splits) == 3
|
|
|
|
# Expected: 33.33, 33.33, 33.34 (sorted by user_id, assuming user1, user2, user3 have ascending ids)
|
|
# The order of users in test_group_api_costs is user1, user2, user3.
|
|
# Their IDs will be ascending.
|
|
expected_amounts = ["33.33", "33.33", "33.34"]
|
|
user_ids = sorted([user1.id, user2.id, user3.id])
|
|
|
|
for i, split in enumerate(splits):
|
|
assert split["user_id"] == user_ids[i]
|
|
assert split["owed_amount"] == expected_amounts[i]
|
|
assert split["status"] == ExpenseSplitStatusEnum.unpaid.value
|
|
|
|
sum_of_splits = sum(Decimal(s["owed_amount"]) for s in splits)
|
|
assert sum_of_splits == Decimal("100.00")
|
|
|
|
async def test_equal_split_divisible(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
db_session: AsyncSession,
|
|
test_user1_api_costs: Dict[str, Any], # For headers
|
|
test_group_api_costs_2_users: Dict[str, Any],
|
|
):
|
|
user1_headers = test_user1_api_costs["headers"] # Payer will be user1
|
|
|
|
group_data = test_group_api_costs_2_users
|
|
group_object = group_data["group"]
|
|
group_members = group_data["members"]
|
|
assert len(group_members) == 2
|
|
|
|
# Ensure user1 (whose headers are used) is part of this group for valid payment
|
|
payer = test_user1_api_costs["user"]
|
|
assert any(member.id == payer.id for member in group_members), "Payer (user1) must be in the 2-user group"
|
|
|
|
expense_payload = {
|
|
"description": "Divisible Equal Split Lunch",
|
|
"total_amount": "50.00",
|
|
"currency": "USD",
|
|
"group_id": group_object.id,
|
|
"paid_by_user_id": payer.id,
|
|
"split_type": SplitTypeEnum.EQUAL.value,
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
assert response.status_code == 201
|
|
created_expense_data = response.json()
|
|
|
|
assert created_expense_data["total_amount"] == "50.00"
|
|
assert created_expense_data["split_type"] == SplitTypeEnum.EQUAL.value
|
|
|
|
expense_id = created_expense_data["id"]
|
|
detail_response = await client.get(f"{settings.API_V1_STR}/expenses/{expense_id}", headers=user1_headers)
|
|
assert detail_response.status_code == 200
|
|
expense_details = detail_response.json()
|
|
|
|
splits = sorted(expense_details["splits"], key=lambda s: s["user_id"])
|
|
assert len(splits) == 2
|
|
|
|
user_ids_in_group = sorted([m.id for m in group_members])
|
|
|
|
for split in splits:
|
|
assert split["owed_amount"] == "25.00"
|
|
assert split["status"] == ExpenseSplitStatusEnum.unpaid.value
|
|
assert split["user_id"] in user_ids_in_group
|
|
|
|
sum_of_splits = sum(Decimal(s["owed_amount"]) for s in splits)
|
|
assert sum_of_splits == Decimal("50.00")
|
|
|
|
async def test_equal_split_with_remainder_distribution(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
db_session: AsyncSession, # Added db_session
|
|
test_user1_api_costs: Dict[str, Any],
|
|
client: httpx.AsyncClient,
|
|
db_session: AsyncSession,
|
|
test_user1_api_costs: Dict[str, Any], # For headers
|
|
test_group_api_costs_4_users: Dict[str, Any],
|
|
):
|
|
user1_headers = test_user1_api_costs["headers"] # Payer will be user1
|
|
|
|
group_data = test_group_api_costs_4_users
|
|
group_object = group_data["group"]
|
|
group_members = group_data["members"]
|
|
assert len(group_members) == 4
|
|
|
|
# Ensure user1 (whose headers are used) is part of this group for valid payment
|
|
payer = test_user1_api_costs["user"]
|
|
assert any(member.id == payer.id for member in group_members), "Payer (user1) must be in the 4-user group"
|
|
|
|
expense_payload = {
|
|
"description": "Remainder Test",
|
|
"total_amount": "101.00",
|
|
"currency": "USD",
|
|
"group_id": group_object.id,
|
|
"paid_by_user_id": payer.id,
|
|
"split_type": SplitTypeEnum.EQUAL.value,
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers, # User1 is the payer
|
|
)
|
|
assert response.status_code == 201
|
|
created_expense_data = response.json()
|
|
|
|
assert created_expense_data["total_amount"] == "101.00"
|
|
|
|
expense_id = created_expense_data["id"]
|
|
detail_response = await client.get(f"{settings.API_V1_STR}/expenses/{expense_id}", headers=user1_headers)
|
|
assert detail_response.status_code == 200
|
|
expense_details = detail_response.json()
|
|
|
|
splits = sorted(expense_details["splits"], key=lambda s: s["user_id"])
|
|
assert len(splits) == 4
|
|
|
|
# 101.00 / 4 = 25.25. Pennies should be distributed.
|
|
# The penny distribution (e.g. first N users get an extra penny) depends on implementation.
|
|
# Let's assume it's 25.25 for all due to ROUND_HALF_UP or similar for base, and then pennies added.
|
|
# Or, 3 users get 25.25 and one gets 25.25, or some get X and some X+0.01
|
|
# The crud function uses: base_share = (total_amount / num_splits).quantize(Decimal("0.01"), rounding=ROUND_DOWN)
|
|
# Then distributes pennies. So for 101/4 = 25.25, ROUND_DOWN is 25.25. No pennies to distribute.
|
|
# All should be 25.25.
|
|
|
|
# If amount was 100.00 / 3 = 33.333...
|
|
# base_share = 33.33. Remaining = 0.01. First user gets 33.34.
|
|
# For 101.00 / 4 = 25.25.
|
|
# base_share = 25.25. total_rounded = 25.25 * 4 = 101.00. Remainder = 0.
|
|
# So all should be 25.25.
|
|
|
|
for split in splits:
|
|
assert split["owed_amount"] == "25.25"
|
|
assert split["status"] == ExpenseSplitStatusEnum.unpaid.value
|
|
|
|
sum_of_splits = sum(Decimal(s["owed_amount"]) for s in splits)
|
|
assert sum_of_splits == Decimal("101.00")
|
|
|
|
async def test_equal_split_single_user_in_group(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
db_session: AsyncSession,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
|
|
# Create a new group with only user1
|
|
single_user_group = Group(name="Single User Group for Equal Split", created_by_id=user1.id)
|
|
db_session.add(single_user_group)
|
|
await db_session.flush()
|
|
|
|
from app.models import UserGroup # Ensure import
|
|
user_group_assoc = UserGroup(user_id=user1.id, group_id=single_user_group.id, role=UserRoleEnum.owner)
|
|
db_session.add(user_group_assoc)
|
|
await db_session.commit()
|
|
await db_session.refresh(single_user_group)
|
|
|
|
expense_payload = {
|
|
"description": "Single User Equal Split",
|
|
"total_amount": "75.00",
|
|
"currency": "USD",
|
|
"group_id": single_user_group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.EQUAL.value,
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
assert response.status_code == 201
|
|
created_expense_data = response.json()
|
|
|
|
assert created_expense_data["total_amount"] == "75.00"
|
|
|
|
expense_id = created_expense_data["id"]
|
|
detail_response = await client.get(f"{settings.API_V1_STR}/expenses/{expense_id}", headers=user1_headers)
|
|
assert detail_response.status_code == 200
|
|
expense_details = detail_response.json()
|
|
|
|
splits = expense_details["splits"]
|
|
assert len(splits) == 1
|
|
|
|
split = splits[0]
|
|
assert split["user_id"] == user1.id
|
|
assert split["owed_amount"] == "75.00"
|
|
assert split["status"] == ExpenseSplitStatusEnum.unpaid.value
|
|
|
|
sum_of_splits = sum(Decimal(s["owed_amount"]) for s in splits)
|
|
assert sum_of_splits == Decimal("75.00")
|
|
|
|
# Need to import selectinload for the group member fetching in divisible/remainder tests
|
|
from sqlalchemy.orm import selectinload
|
|
# Need AsyncSession for type hinting db_session
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
class TestExactAmountsSplitExpenses:
|
|
async def test_exact_amounts_basic(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_user3_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
user3 = test_user3_api_costs["user"]
|
|
group = test_group_api_costs
|
|
|
|
expense_payload = {
|
|
"description": "Exact Amounts Split Event",
|
|
"total_amount": "100.00",
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.EXACT_AMOUNTS.value,
|
|
"splits_in": [
|
|
{"user_id": user1.id, "owed_amount": "20.00"},
|
|
{"user_id": user2.id, "owed_amount": "30.00"},
|
|
{"user_id": user3.id, "owed_amount": "50.00"},
|
|
],
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
assert response.status_code == 201
|
|
created_expense_data = response.json()
|
|
|
|
assert created_expense_data["total_amount"] == "100.00"
|
|
assert created_expense_data["split_type"] == SplitTypeEnum.EXACT_AMOUNTS.value
|
|
assert created_expense_data["paid_by_user_id"] == user1.id
|
|
|
|
expense_id = created_expense_data["id"]
|
|
detail_response = await client.get(f"{settings.API_V1_STR}/expenses/{expense_id}", headers=user1_headers)
|
|
assert detail_response.status_code == 200
|
|
expense_details = detail_response.json()
|
|
|
|
splits = sorted(expense_details["splits"], key=lambda s: s["user_id"])
|
|
assert len(splits) == 3
|
|
|
|
expected_splits = {
|
|
user1.id: "20.00",
|
|
user2.id: "30.00",
|
|
user3.id: "50.00",
|
|
}
|
|
|
|
for split in splits:
|
|
assert split["owed_amount"] == expected_splits[split["user_id"]]
|
|
assert split["status"] == ExpenseSplitStatusEnum.unpaid.value
|
|
|
|
sum_of_splits = sum(Decimal(s["owed_amount"]) for s in splits)
|
|
assert sum_of_splits == Decimal("100.00")
|
|
|
|
async def test_exact_amounts_validation_sum_mismatch(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
group = test_group_api_costs
|
|
|
|
expense_payload = {
|
|
"description": "Sum Mismatch Test",
|
|
"total_amount": "100.00", # Total amount
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.EXACT_AMOUNTS.value,
|
|
"splits_in": [
|
|
{"user_id": user1.id, "owed_amount": "20.00"},
|
|
{"user_id": user2.id, "owed_amount": "30.00"}, # Sums to 50, not 100
|
|
],
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
# Expecting 400 due to sum mismatch from crud_expense validation
|
|
assert response.status_code == 400
|
|
error_detail = response.json()["detail"]
|
|
assert "Sum of split amounts must equal total expense amount" in error_detail
|
|
|
|
|
|
async def test_exact_amounts_validation_negative_amount(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
group = test_group_api_costs
|
|
|
|
expense_payload = {
|
|
"description": "Negative Amount Test",
|
|
"total_amount": "10.00",
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.EXACT_AMOUNTS.value,
|
|
"splits_in": [
|
|
{"user_id": user1.id, "owed_amount": "-5.00"}, # Negative amount
|
|
],
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
# Pydantic validation on SplitCreate should catch negative owed_amount
|
|
assert response.status_code == 422
|
|
# Example check, details might vary based on Pydantic error formatting
|
|
assert "value_error" in response.json()["detail"][0]["type"]
|
|
assert "must be greater than 0" in response.json()["detail"][0]["msg"]
|
|
|
|
|
|
async def test_exact_amounts_validation_missing_user_in_split(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
group = test_group_api_costs
|
|
non_existent_user_id = 99999
|
|
|
|
expense_payload = {
|
|
"description": "Missing User in Split Test",
|
|
"total_amount": "50.00",
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.EXACT_AMOUNTS.value,
|
|
"splits_in": [
|
|
{"user_id": user1.id, "owed_amount": "25.00"},
|
|
{"user_id": non_existent_user_id, "owed_amount": "25.00"},
|
|
],
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
# crud_expense._validate_and_get_users_for_splitting should catch this
|
|
assert response.status_code == 404
|
|
error_detail = response.json()["detail"]
|
|
assert f"User with ID {non_existent_user_id} not found or not part of group {group.id}" in error_detail
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
class TestPercentageSplitExpenses:
|
|
async def test_percentage_basic(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_user3_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
user3 = test_user3_api_costs["user"]
|
|
group = test_group_api_costs
|
|
|
|
expense_payload = {
|
|
"description": "Basic Percentage Split",
|
|
"total_amount": "100.00",
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.PERCENTAGE.value,
|
|
"splits_in": [
|
|
{"user_id": user1.id, "percentage": "25.00"},
|
|
{"user_id": user2.id, "percentage": "25.00"},
|
|
{"user_id": user3.id, "percentage": "50.00"},
|
|
],
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
assert response.status_code == 201
|
|
created_expense_data = response.json()
|
|
|
|
assert created_expense_data["total_amount"] == "100.00"
|
|
assert created_expense_data["split_type"] == SplitTypeEnum.PERCENTAGE.value
|
|
|
|
expense_id = created_expense_data["id"]
|
|
detail_response = await client.get(f"{settings.API_V1_STR}/expenses/{expense_id}", headers=user1_headers)
|
|
assert detail_response.status_code == 200
|
|
expense_details = detail_response.json()
|
|
|
|
splits = sorted(expense_details["splits"], key=lambda s: s["user_id"])
|
|
assert len(splits) == 3
|
|
|
|
expected_amounts = {
|
|
user1.id: "25.00",
|
|
user2.id: "25.00",
|
|
user3.id: "50.00",
|
|
}
|
|
for split in splits:
|
|
assert split["owed_amount"] == expected_amounts[split["user_id"]]
|
|
|
|
sum_of_splits = sum(Decimal(s["owed_amount"]) for s in splits)
|
|
assert sum_of_splits == Decimal("100.00")
|
|
|
|
async def test_percentage_with_rounding(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_user3_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
user3 = test_user3_api_costs["user"]
|
|
group = test_group_api_costs
|
|
|
|
expense_payload = {
|
|
"description": "Percentage Split with Rounding",
|
|
"total_amount": "100.00",
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.PERCENTAGE.value,
|
|
"splits_in": [
|
|
{"user_id": user1.id, "percentage": "33.33"},
|
|
{"user_id": user2.id, "percentage": "33.33"},
|
|
{"user_id": user3.id, "percentage": "33.34"}, # Sums to 100%
|
|
],
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
assert response.status_code == 201
|
|
created_expense_data = response.json()
|
|
|
|
expense_id = created_expense_data["id"]
|
|
detail_response = await client.get(f"{settings.API_V1_STR}/expenses/{expense_id}", headers=user1_headers)
|
|
assert detail_response.status_code == 200
|
|
expense_details = detail_response.json()
|
|
|
|
splits = sorted(expense_details["splits"], key=lambda s: s["user_id"])
|
|
assert len(splits) == 3
|
|
|
|
# Based on current penny distribution (first user gets remainder)
|
|
# User1: 100 * 0.3333 = 33.33
|
|
# User2: 100 * 0.3333 = 33.33
|
|
# User3: 100 * 0.3334 = 33.34
|
|
# Sum = 100.00. The crud logic for percentage splits distributes pennies.
|
|
|
|
user_ids_sorted = sorted([user1.id, user2.id, user3.id])
|
|
expected_amounts = {
|
|
user_ids_sorted[0]: "33.33", # User1
|
|
user_ids_sorted[1]: "33.33", # User2
|
|
user_ids_sorted[2]: "33.34", # User3
|
|
}
|
|
# Check if penny went to the one with higher percentage if not perfectly distributed by input already
|
|
# The current logic in `_create_percentage_splits` calculates shares and then distributes pennies
|
|
# similar to equal split. It doesn't necessarily assign the remainder based on the input percentages
|
|
# if those percentages themselves don't perfectly sum to 100.00 after calculation.
|
|
# However, if percentages sum to 100, the calculated amounts should match.
|
|
# Let's verify the actual amounts from the test:
|
|
# User1 gets 33.33. User2 gets 33.33. User3 gets 33.34.
|
|
# This matches the input percentages directly applied.
|
|
# The penny distribution logic in `_distribute_remainder` might adjust if the sum of calculated shares is off.
|
|
|
|
for split in splits:
|
|
assert split["owed_amount"] == expected_amounts[split["user_id"]]
|
|
|
|
sum_of_splits = sum(Decimal(s["owed_amount"]) for s in splits)
|
|
assert sum_of_splits == Decimal("100.00")
|
|
|
|
async def test_percentage_validation_sum_not_100(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
group = test_group_api_costs
|
|
|
|
expense_payload = {
|
|
"description": "Percentage Sum Not 100",
|
|
"total_amount": "100.00",
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.PERCENTAGE.value,
|
|
"splits_in": [
|
|
{"user_id": user1.id, "percentage": "20.00"},
|
|
{"user_id": user2.id, "percentage": "30.00"}, # Sums to 50%
|
|
],
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
assert response.status_code == 400
|
|
error_detail = response.json()["detail"]
|
|
assert "Percentages must sum to 100" in error_detail
|
|
|
|
async def test_percentage_validation_invalid_percentage(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
group = test_group_api_costs
|
|
|
|
expense_payload = {
|
|
"description": "Invalid Percentage Value",
|
|
"total_amount": "100.00",
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.PERCENTAGE.value,
|
|
"splits_in": [
|
|
{"user_id": user1.id, "percentage": "110.00"}, # Invalid percentage
|
|
],
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
assert response.status_code == 422 # Pydantic validation on percentage value (0-100)
|
|
# Example check, details might vary
|
|
assert "value_error" in response.json()["detail"][0]["type"]
|
|
assert "Percentage must be between 0 and 100" in response.json()["detail"][0]["msg"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
class TestSharesSplitExpenses:
|
|
async def test_shares_basic(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_user3_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
user3 = test_user3_api_costs["user"]
|
|
group = test_group_api_costs
|
|
|
|
expense_payload = {
|
|
"description": "Basic Shares Split",
|
|
"total_amount": "60.00", # Total 6 shares (1+2+3), 60/6 = 10 per share
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.SHARES.value,
|
|
"splits_in": [
|
|
{"user_id": user1.id, "shares": 1},
|
|
{"user_id": user2.id, "shares": 2},
|
|
{"user_id": user3.id, "shares": 3},
|
|
],
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
assert response.status_code == 201
|
|
created_expense_data = response.json()
|
|
|
|
assert created_expense_data["total_amount"] == "60.00"
|
|
assert created_expense_data["split_type"] == SplitTypeEnum.SHARES.value
|
|
|
|
expense_id = created_expense_data["id"]
|
|
detail_response = await client.get(f"{settings.API_V1_STR}/expenses/{expense_id}", headers=user1_headers)
|
|
assert detail_response.status_code == 200
|
|
expense_details = detail_response.json()
|
|
|
|
splits = sorted(expense_details["splits"], key=lambda s: s["user_id"])
|
|
assert len(splits) == 3
|
|
|
|
expected_amounts = {
|
|
user1.id: "10.00", # 1 share * 10
|
|
user2.id: "20.00", # 2 shares * 10
|
|
user3.id: "30.00", # 3 shares * 10
|
|
}
|
|
for split in splits:
|
|
assert split["owed_amount"] == expected_amounts[split["user_id"]]
|
|
|
|
sum_of_splits = sum(Decimal(s["owed_amount"]) for s in splits)
|
|
assert sum_of_splits == Decimal("60.00")
|
|
|
|
async def test_shares_with_rounding(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_user3_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
user3 = test_user3_api_costs["user"]
|
|
group = test_group_api_costs
|
|
|
|
expense_payload = {
|
|
"description": "Shares Split with Rounding",
|
|
"total_amount": "100.00", # Total 3 shares (1+1+1)
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.SHARES.value,
|
|
"splits_in": [
|
|
{"user_id": user1.id, "shares": 1},
|
|
{"user_id": user2.id, "shares": 1},
|
|
{"user_id": user3.id, "shares": 1},
|
|
],
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
assert response.status_code == 201
|
|
created_expense_data = response.json()
|
|
|
|
expense_id = created_expense_data["id"]
|
|
detail_response = await client.get(f"{settings.API_V1_STR}/expenses/{expense_id}", headers=user1_headers)
|
|
assert detail_response.status_code == 200
|
|
expense_details = detail_response.json()
|
|
|
|
splits = sorted(expense_details["splits"], key=lambda s: s["user_id"])
|
|
assert len(splits) == 3
|
|
|
|
# 100.00 / 3 shares = 33.333... per share.
|
|
# Expected: 33.33, 33.33, 33.34 (penny distribution applies)
|
|
user_ids_sorted = sorted([user1.id, user2.id, user3.id])
|
|
expected_amounts = {
|
|
user_ids_sorted[0]: "33.33",
|
|
user_ids_sorted[1]: "33.33",
|
|
user_ids_sorted[2]: "33.34",
|
|
}
|
|
for split in splits:
|
|
assert split["owed_amount"] == expected_amounts[split["user_id"]]
|
|
|
|
sum_of_splits = sum(Decimal(s["owed_amount"]) for s in splits)
|
|
assert sum_of_splits == Decimal("100.00")
|
|
|
|
async def test_shares_validation_zero_total_shares(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
group = test_group_api_costs
|
|
|
|
expense_payload = {
|
|
"description": "Zero Total Shares",
|
|
"total_amount": "100.00",
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.SHARES.value,
|
|
"splits_in": [
|
|
{"user_id": user1.id, "shares": 0},
|
|
{"user_id": user2.id, "shares": 0},
|
|
],
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
assert response.status_code == 400
|
|
error_detail = response.json()["detail"]
|
|
assert "Total shares must be greater than zero" in error_detail
|
|
|
|
async def test_shares_validation_negative_shares(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
group = test_group_api_costs
|
|
|
|
expense_payload = {
|
|
"description": "Invalid Negative Shares",
|
|
"total_amount": "100.00",
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.SHARES.value,
|
|
"splits_in": [
|
|
{"user_id": user1.id, "shares": -1},
|
|
],
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
assert response.status_code == 422 # Pydantic validation on shares value (>=0)
|
|
# Example check, details might vary
|
|
assert "value_error" in response.json()["detail"][0]["type"]
|
|
assert "Shares must be non-negative" in response.json()["detail"][0]["msg"] # Adjusted expected message
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
class TestItemBasedSplitExpenses:
|
|
@pytest.fixture
|
|
async def test_list_for_item_based_split(
|
|
self,
|
|
db_session: AsyncSession,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
) -> ListModel:
|
|
user1 = test_user1_api_costs["user"]
|
|
group = test_group_api_costs
|
|
|
|
shopping_list = ListModel(
|
|
name="Shopping List for Item-Based Split",
|
|
group_id=group.id,
|
|
created_by_id=user1.id,
|
|
)
|
|
db_session.add(shopping_list)
|
|
await db_session.commit()
|
|
await db_session.refresh(shopping_list)
|
|
return shopping_list
|
|
|
|
async def test_item_based_split_basic(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
db_session: AsyncSession,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
test_list_for_item_based_split: ListModel,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
shopping_list = test_list_for_item_based_split
|
|
|
|
# Add items to the list
|
|
items_data = [
|
|
{"description": "Item 1", "price": Decimal("10.00"), "added_by_user_id": user1.id, "list_id": shopping_list.id},
|
|
{"description": "Item 2", "price": Decimal("20.00"), "added_by_user_id": user2.id, "list_id": shopping_list.id},
|
|
{"description": "Item 3", "price": Decimal("30.00"), "added_by_user_id": user1.id, "list_id": shopping_list.id},
|
|
]
|
|
for item_data in items_data:
|
|
item = ItemModel(**item_data)
|
|
db_session.add(item)
|
|
await db_session.commit()
|
|
|
|
expense_payload = {
|
|
"description": "Item-Based Split Dinner",
|
|
"total_amount": "60.00", # Sum of item prices (10+20+30)
|
|
"currency": "USD",
|
|
"group_id": test_group_api_costs.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.ITEM_BASED.value,
|
|
"list_id": shopping_list.id,
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
assert response.status_code == 201
|
|
created_expense_data = response.json()
|
|
|
|
assert created_expense_data["total_amount"] == "60.00"
|
|
assert created_expense_data["split_type"] == SplitTypeEnum.ITEM_BASED.value
|
|
assert created_expense_data["paid_by_user_id"] == user1.id
|
|
|
|
expense_id = created_expense_data["id"]
|
|
detail_response = await client.get(f"{settings.API_V1_STR}/expenses/{expense_id}", headers=user1_headers)
|
|
assert detail_response.status_code == 200
|
|
expense_details = detail_response.json()
|
|
|
|
splits = sorted(expense_details["splits"], key=lambda s: s["user_id"])
|
|
# User3 is in the group but added no items, so should not have a split.
|
|
assert len(splits) == 2
|
|
|
|
expected_splits = {
|
|
user1.id: "40.00", # 10 + 30
|
|
user2.id: "20.00",
|
|
}
|
|
|
|
for split in splits:
|
|
assert split["owed_amount"] == expected_splits[split["user_id"]]
|
|
assert split["status"] == ExpenseSplitStatusEnum.unpaid.value
|
|
|
|
sum_of_splits = sum(Decimal(s["owed_amount"]) for s in splits)
|
|
assert sum_of_splits == Decimal("60.00")
|
|
|
|
async def test_item_based_split_single_user_adds_all_items(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
db_session: AsyncSession,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group, # Group contains user1, user2, user3
|
|
test_list_for_item_based_split: ListModel,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
shopping_list = test_list_for_item_based_split
|
|
|
|
items_data = [
|
|
{"description": "Item A", "price": Decimal("15.00"), "added_by_user_id": user1.id, "list_id": shopping_list.id},
|
|
{"description": "Item B", "price": Decimal("25.00"), "added_by_user_id": user1.id, "list_id": shopping_list.id},
|
|
]
|
|
for item_data in items_data:
|
|
item = ItemModel(**item_data)
|
|
db_session.add(item)
|
|
await db_session.commit()
|
|
|
|
expense_payload = {
|
|
"description": "Single User All Items",
|
|
"total_amount": "40.00",
|
|
"currency": "USD",
|
|
"group_id": test_group_api_costs.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.ITEM_BASED.value,
|
|
"list_id": shopping_list.id,
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
assert response.status_code == 201
|
|
created_expense_data = response.json()
|
|
|
|
assert created_expense_data["total_amount"] == "40.00"
|
|
|
|
expense_id = created_expense_data["id"]
|
|
detail_response = await client.get(f"{settings.API_V1_STR}/expenses/{expense_id}", headers=user1_headers)
|
|
assert detail_response.status_code == 200
|
|
expense_details = detail_response.json()
|
|
|
|
splits = expense_details["splits"]
|
|
assert len(splits) == 1
|
|
|
|
split = splits[0]
|
|
assert split["user_id"] == user1.id
|
|
assert split["owed_amount"] == "40.00"
|
|
assert split["status"] == ExpenseSplitStatusEnum.unpaid.value
|
|
|
|
sum_of_splits = sum(Decimal(s["owed_amount"]) for s in splits)
|
|
assert sum_of_splits == Decimal("40.00")
|
|
|
|
async def test_item_based_split_with_zero_price_items(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
db_session: AsyncSession,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any], # User2 adds zero price item
|
|
test_group_api_costs: Group,
|
|
test_list_for_item_based_split: ListModel,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
shopping_list = test_list_for_item_based_split
|
|
|
|
items_data = [
|
|
{"description": "Item X1", "price": Decimal("10.00"), "added_by_user_id": user1.id, "list_id": shopping_list.id},
|
|
{"description": "Item X2", "price": Decimal("0.00"), "added_by_user_id": user2.id, "list_id": shopping_list.id},
|
|
{"description": "Item X3", "price": Decimal("5.00"), "added_by_user_id": user1.id, "list_id": shopping_list.id},
|
|
]
|
|
for item_data in items_data:
|
|
item = ItemModel(**item_data)
|
|
db_session.add(item)
|
|
await db_session.commit()
|
|
|
|
expense_payload = {
|
|
"description": "Zero Price Items Test",
|
|
"total_amount": "15.00", # 10 + 5
|
|
"currency": "USD",
|
|
"group_id": test_group_api_costs.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.ITEM_BASED.value,
|
|
"list_id": shopping_list.id,
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
assert response.status_code == 201
|
|
created_expense_data = response.json()
|
|
|
|
assert created_expense_data["total_amount"] == "15.00"
|
|
|
|
expense_id = created_expense_data["id"]
|
|
detail_response = await client.get(f"{settings.API_V1_STR}/expenses/{expense_id}", headers=user1_headers)
|
|
assert detail_response.status_code == 200
|
|
expense_details = detail_response.json()
|
|
|
|
splits = expense_details["splits"]
|
|
assert len(splits) == 1 # Only User1 has splits from priced items
|
|
|
|
split = splits[0]
|
|
assert split["user_id"] == user1.id
|
|
assert split["owed_amount"] == "15.00"
|
|
|
|
sum_of_splits = sum(Decimal(s["owed_amount"]) for s in splits)
|
|
assert sum_of_splits == Decimal("15.00")
|
|
|
|
async def test_item_based_split_list_with_no_priced_items(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
db_session: AsyncSession,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
test_list_for_item_based_split: ListModel,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
shopping_list = test_list_for_item_based_split
|
|
|
|
items_data = [
|
|
{"description": "NoPrice 1", "price": Decimal("0.00"), "added_by_user_id": user1.id, "list_id": shopping_list.id},
|
|
{"description": "NoPrice 2", "added_by_user_id": user2.id, "list_id": shopping_list.id}, # price is None
|
|
]
|
|
for item_data in items_data:
|
|
item = ItemModel(**item_data)
|
|
db_session.add(item)
|
|
await db_session.commit()
|
|
|
|
expense_payload = {
|
|
"description": "No Priced Items Test",
|
|
"total_amount": "0.00", # This will be the sum from items
|
|
"currency": "USD",
|
|
"group_id": test_group_api_costs.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.ITEM_BASED.value,
|
|
"list_id": shopping_list.id,
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
# crud_expense.py: _create_item_based_splits raises ValueError if no relevant items or total is zero.
|
|
# This translates to a 400 error.
|
|
assert response.status_code == 400
|
|
error_detail = response.json()["detail"]
|
|
assert "No items with a positive price found for this list to create an item-based split" in error_detail \
|
|
or "Total amount for item-based split must be greater than zero" in error_detail
|
|
|
|
async def test_item_based_split_linked_to_specific_item(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
db_session: AsyncSession,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
test_list_for_item_based_split: ListModel,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
shopping_list = test_list_for_item_based_split
|
|
|
|
item_a = ItemModel(description="Item A", price=Decimal("50.00"), added_by_user_id=user1.id, list_id=shopping_list.id)
|
|
item_b = ItemModel(description="Item B", price=Decimal("70.00"), added_by_user_id=user2.id, list_id=shopping_list.id)
|
|
db_session.add_all([item_a, item_b])
|
|
await db_session.commit()
|
|
await db_session.refresh(item_a)
|
|
await db_session.refresh(item_b)
|
|
|
|
# Scenario 1: Correct amount linked to item_a
|
|
expense_payload_item_a = {
|
|
"description": "Expense for Item A",
|
|
"total_amount": "50.00",
|
|
"currency": "USD",
|
|
"group_id": test_group_api_costs.id, # Group ID is still relevant for context
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.ITEM_BASED.value,
|
|
"item_id": item_a.id, # Linking to specific item
|
|
}
|
|
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload_item_a,
|
|
headers=user1_headers,
|
|
)
|
|
assert response.status_code == 201
|
|
created_expense_data = response.json()
|
|
|
|
assert created_expense_data["total_amount"] == "50.00"
|
|
assert created_expense_data["item_id"] == item_a.id
|
|
|
|
expense_id = created_expense_data["id"]
|
|
detail_response = await client.get(f"{settings.API_V1_STR}/expenses/{expense_id}", headers=user1_headers)
|
|
assert detail_response.status_code == 200
|
|
expense_details = detail_response.json()
|
|
|
|
splits = expense_details["splits"]
|
|
assert len(splits) == 1
|
|
assert splits[0]["user_id"] == user1.id
|
|
assert splits[0]["owed_amount"] == "50.00"
|
|
|
|
# Scenario 2: Mismatched total_amount for item_a
|
|
expense_payload_item_a_mismatch = {
|
|
"description": "Expense for Item A Mismatch",
|
|
"total_amount": "40.00", # Incorrect amount
|
|
"currency": "USD",
|
|
"group_id": test_group_api_costs.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.ITEM_BASED.value,
|
|
"item_id": item_a.id,
|
|
}
|
|
response_mismatch = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload_item_a_mismatch,
|
|
headers=user1_headers,
|
|
)
|
|
# crud_expense.py validation: "Total amount for item-based split on a specific item must match item's price."
|
|
assert response_mismatch.status_code == 400
|
|
assert "must match item's price" in response_mismatch.json()["detail"]
|
|
|
|
async def test_item_based_split_validation_list_not_found(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
non_existent_list_id = 9999
|
|
|
|
expense_payload = {
|
|
"description": "List Not Found Test",
|
|
"total_amount": "10.00",
|
|
"currency": "USD",
|
|
"group_id": test_group_api_costs.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.ITEM_BASED.value,
|
|
"list_id": non_existent_list_id,
|
|
}
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
# crud_expense.py raises ListNotFoundError if list_id is provided but not found.
|
|
assert response.status_code == 404
|
|
assert f"List with ID {non_existent_list_id} not found" in response.json()["detail"]
|
|
|
|
async def test_item_based_split_validation_total_amount_mismatch_with_list_items(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
db_session: AsyncSession,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
test_list_for_item_based_split: ListModel,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
shopping_list = test_list_for_item_based_split
|
|
|
|
# Items sum to 50.00
|
|
item1 = ItemModel(description="Item C1", price=Decimal("20.00"), added_by_user_id=user1.id, list_id=shopping_list.id)
|
|
item2 = ItemModel(description="Item C2", price=Decimal("30.00"), added_by_user_id=user1.id, list_id=shopping_list.id)
|
|
db_session.add_all([item1, item2])
|
|
await db_session.commit()
|
|
|
|
expense_payload = {
|
|
"description": "Total Amount Mismatch with List Items",
|
|
"total_amount": "45.00", # Mismatched amount
|
|
"currency": "USD",
|
|
"group_id": test_group_api_costs.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.ITEM_BASED.value,
|
|
"list_id": shopping_list.id,
|
|
}
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/",
|
|
json=expense_payload,
|
|
headers=user1_headers,
|
|
)
|
|
# crud_expense.py validation: "Total amount for item-based split must equal the sum of relevant item prices from the list."
|
|
assert response.status_code == 400
|
|
assert "must equal the sum of relevant item prices" in response.json()["detail"]
|
|
|
|
# Need to import ListModel and ItemModel
|
|
from app.models import ListModel, ItemModel, Settlement as SettlementModel
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
class TestGroupBalanceSummaryCalculations:
|
|
async def _get_expense_splits(self, client: httpx.AsyncClient, expense_id: int, headers: Dict[str, str]) -> List[Dict[str, Any]]:
|
|
"""Helper to fetch expense details and return its splits."""
|
|
response = await client.get(f"{settings.API_V1_STR}/expenses/{expense_id}", headers=headers)
|
|
response.raise_for_status()
|
|
return response.json()["splits"]
|
|
|
|
async def _create_settlement_activity(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
expense_split_id: int,
|
|
paid_by_user_id: int,
|
|
amount: str,
|
|
headers: Dict[str, str]
|
|
):
|
|
"""Helper to create a settlement activity."""
|
|
payload = {
|
|
"expense_split_id": expense_split_id,
|
|
"paid_by_user_id": paid_by_user_id,
|
|
"amount_paid": amount,
|
|
}
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expense_splits/{expense_split_id}/settle",
|
|
json=payload,
|
|
headers=headers,
|
|
)
|
|
response.raise_for_status()
|
|
return response.json()
|
|
|
|
async def _create_generic_settlement(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
group_id: int,
|
|
paid_by_user_id: int,
|
|
paid_to_user_id: int,
|
|
amount: str,
|
|
headers: Dict[str, str]
|
|
):
|
|
"""Helper to create a generic settlement."""
|
|
payload = {
|
|
"group_id": group_id,
|
|
"paid_by_user_id": paid_by_user_id,
|
|
"paid_to_user_id": paid_to_user_id,
|
|
"amount": amount,
|
|
"description": "Generic settlement"
|
|
}
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/settlements/",
|
|
json=payload,
|
|
headers=headers
|
|
)
|
|
response.raise_for_status()
|
|
return response.json()
|
|
|
|
|
|
async def test_balance_summary_no_settlement_activities(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_user3_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group, # Group with U1, U2, U3
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
user3 = test_user3_api_costs["user"]
|
|
group = test_group_api_costs
|
|
|
|
# Create an expense: User1 paid 100, split EQUAL among User1, User2, User3
|
|
expense_payload = {
|
|
"description": "Dinner - No Settlements",
|
|
"total_amount": "100.00",
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.EQUAL.value,
|
|
}
|
|
response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/", json=expense_payload, headers=user1_headers
|
|
)
|
|
assert response.status_code == 201
|
|
|
|
# Get balance summary
|
|
summary_response = await client.get(
|
|
f"{settings.API_V1_STR}/groups/{group.id}/balance-summary", headers=user1_headers
|
|
)
|
|
assert summary_response.status_code == 200
|
|
summary_data = summary_response.json()
|
|
|
|
user_balances = {ub["user_id"]: ub for ub in summary_data["user_balances"]}
|
|
|
|
# Expected:
|
|
# User1: paid 100, share 33.33. Net: 100 - 33.33 = +66.67
|
|
# User2: paid 0, share 33.33. Net: 0 - 33.33 = -33.33
|
|
# User3: paid 0, share 33.34. Net: 0 - 33.34 = -33.34
|
|
# Sum = 0
|
|
|
|
# User1 assertions
|
|
assert user_balances[user1.id]["total_paid_for_expenses"] == "100.00"
|
|
assert user_balances[user1.id]["total_share_of_expenses"] == "33.33" # Adjusted share is initial share here
|
|
assert user_balances[user1.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user1.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user1.id]["net_balance"] == "66.67"
|
|
|
|
# User2 assertions
|
|
assert user_balances[user2.id]["total_paid_for_expenses"] == "0.00"
|
|
assert user_balances[user2.id]["total_share_of_expenses"] == "33.33"
|
|
assert user_balances[user2.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user2.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user2.id]["net_balance"] == "-33.33"
|
|
|
|
# User3 assertions
|
|
assert user_balances[user3.id]["total_paid_for_expenses"] == "0.00"
|
|
assert user_balances[user3.id]["total_share_of_expenses"] == "33.34"
|
|
assert user_balances[user3.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user3.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user3.id]["net_balance"] == "-33.34"
|
|
|
|
# Sum of net balances
|
|
sum_net_balances = sum(Decimal(ub["net_balance"]) for ub in user_balances.values())
|
|
assert sum_net_balances == Decimal("0.00")
|
|
|
|
# Suggested settlements
|
|
# User2 pays User1 33.33. User3 pays User1 33.34.
|
|
suggested = sorted(summary_data["suggested_settlements"], key=lambda s: s["from_user_id"])
|
|
assert len(suggested) == 2
|
|
|
|
assert suggested[0]["from_user_id"] == user2.id
|
|
assert suggested[0]["to_user_id"] == user1.id
|
|
assert suggested[0]["amount"] == "33.33"
|
|
|
|
assert suggested[1]["from_user_id"] == user3.id
|
|
assert suggested[1]["to_user_id"] == user1.id
|
|
assert suggested[1]["amount"] == "33.34"
|
|
|
|
async def test_balance_summary_multiple_settlement_activities_different_expenses(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_user3_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group, # Group with U1, U2, U3
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
user2_headers = test_user2_api_costs["headers"]
|
|
user3 = test_user3_api_costs["user"]
|
|
user3_headers = test_user3_api_costs["headers"] # For User3 to make a settlement
|
|
group = test_group_api_costs
|
|
|
|
# Expense 1: User1 pays 100, split U1, U2 (50, 50)
|
|
# Forcing specific users in EQUAL split by creating a temporary specific split definition
|
|
exp1_payload = {
|
|
"description": "Expense 1 - U1, U2",
|
|
"total_amount": "100.00",
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.EXACT_AMOUNTS.value, # Use EXACT to specify participants easily
|
|
"splits_in": [
|
|
{"user_id": user1.id, "owed_amount": "50.00"},
|
|
{"user_id": user2.id, "owed_amount": "50.00"},
|
|
]
|
|
}
|
|
exp1_response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/", json=exp1_payload, headers=user1_headers
|
|
)
|
|
assert exp1_response.status_code == 201
|
|
expense1_id = exp1_response.json()["id"]
|
|
|
|
exp1_splits = await self._get_expense_splits(client, expense1_id, user1_headers)
|
|
user2_exp1_split = next(s for s in exp1_splits if s["user_id"] == user2.id)
|
|
|
|
# User2 pays their 50 for Expense 1 via SA
|
|
await self._create_settlement_activity(
|
|
client, user2_exp1_split["id"], user2.id, "50.00", user2_headers
|
|
)
|
|
|
|
# Expense 2: User2 pays 60, split U2, U3 (30, 30)
|
|
exp2_payload = {
|
|
"description": "Expense 2 - U2, U3",
|
|
"total_amount": "60.00",
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user2.id,
|
|
"split_type": SplitTypeEnum.EXACT_AMOUNTS.value, # Use EXACT
|
|
"splits_in": [
|
|
{"user_id": user2.id, "owed_amount": "30.00"},
|
|
{"user_id": user3.id, "owed_amount": "30.00"},
|
|
]
|
|
}
|
|
exp2_response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/", json=exp2_payload, headers=user2_headers # User2 creates
|
|
)
|
|
assert exp2_response.status_code == 201
|
|
expense2_id = exp2_response.json()["id"]
|
|
|
|
exp2_splits = await self._get_expense_splits(client, expense2_id, user2_headers)
|
|
user3_exp2_split = next(s for s in exp2_splits if s["user_id"] == user3.id)
|
|
|
|
# User3 pays their 30 for Expense 2 via SA
|
|
await self._create_settlement_activity(
|
|
client, user3_exp2_split["id"], user3.id, "30.00", user3_headers
|
|
)
|
|
|
|
# Get balance summary
|
|
summary_response = await client.get(
|
|
f"{settings.API_V1_STR}/groups/{group.id}/balance-summary", headers=user1_headers
|
|
)
|
|
assert summary_response.status_code == 200
|
|
summary_data = summary_response.json()
|
|
user_balances = {ub["user_id"]: ub for ub in summary_data["user_balances"]}
|
|
|
|
# Expected balances: All should be 0.00
|
|
# User1: Exp1(paid 100, share 50, U2 SA covered their part). Exp2(not involved). Net = 0.
|
|
# total_paid_for_expenses = 100.00
|
|
# initial_total_share_of_expenses = 50.00 (from Exp1)
|
|
# total_amount_paid_via_settlement_activities = 0 (U1 made no SA payments)
|
|
# adjusted_total_share_of_expenses = 50.00
|
|
# net_balance = (100 + 0) - (50 + 0) = 50. This logic is for U1 in isolation.
|
|
# Considering U2 paid U1 50, U1 is 0.
|
|
# User2: Exp1(share 50, paid 50 SA). Exp2(paid 60, share 30, U3 SA covered their part). Net = 0.
|
|
# total_paid_for_expenses = 60.00 (from Exp2)
|
|
# initial_total_share_of_expenses = 50.00 (Exp1) + 30.00 (Exp2) = 80.00
|
|
# total_amount_paid_via_settlement_activities = 50.00 (for Exp1)
|
|
# adjusted_total_share_of_expenses = 80.00 - 50.00 = 30.00
|
|
# net_balance = (60 + 0) - (30 + 0) = 30. This is if U3 hadn't paid U2.
|
|
# Considering U3 paid U2 30, U2 is 0.
|
|
# User3: Exp1(not involved). Exp2(share 30, paid 30 SA). Net = 0.
|
|
# total_paid_for_expenses = 0.00
|
|
# initial_total_share_of_expenses = 30.00 (from Exp2)
|
|
# total_amount_paid_via_settlement_activities = 30.00 (for Exp2)
|
|
# adjusted_total_share_of_expenses = 30.00 - 30.00 = 0.00
|
|
# net_balance = (0 + 0) - (0 + 0) = 0.00
|
|
|
|
# User1 assertions
|
|
assert user_balances[user1.id]["total_paid_for_expenses"] == "100.00"
|
|
assert user_balances[user1.id]["total_share_of_expenses"] == "50.00"
|
|
assert user_balances[user1.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user1.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user1.id]["net_balance"] == "0.00"
|
|
|
|
# User2 assertions
|
|
assert user_balances[user2.id]["total_paid_for_expenses"] == "60.00"
|
|
assert user_balances[user2.id]["total_share_of_expenses"] == "30.00" # (50 from E1 - 50 SA) + (30 from E2) = 30
|
|
assert user_balances[user2.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user2.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user2.id]["net_balance"] == "0.00"
|
|
|
|
# User3 assertions
|
|
assert user_balances[user3.id]["total_paid_for_expenses"] == "0.00"
|
|
assert user_balances[user3.id]["total_share_of_expenses"] == "0.00" # (30 from E2 - 30 SA) = 0
|
|
assert user_balances[user3.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user3.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user3.id]["net_balance"] == "0.00"
|
|
|
|
sum_net_balances = sum(Decimal(ub["net_balance"]) for ub in user_balances.values())
|
|
assert sum_net_balances == Decimal("0.00")
|
|
|
|
# Suggested settlements: Should be empty
|
|
suggested = summary_data["suggested_settlements"]
|
|
assert len(suggested) == 0
|
|
|
|
async def test_balance_summary_interaction_with_generic_settlements(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_user3_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
user2_headers = test_user2_api_costs["headers"]
|
|
user3 = test_user3_api_costs["user"]
|
|
user3_headers = test_user3_api_costs["headers"] # For User3 to make a generic settlement
|
|
group = test_group_api_costs
|
|
|
|
# Expense: User1 paid 100, split EQUAL among User1, User2, User3
|
|
expense_payload = {
|
|
"description": "Dinner - SA and Generic Settlement",
|
|
"total_amount": "100.00",
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.EQUAL.value,
|
|
}
|
|
exp_response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/", json=expense_payload, headers=user1_headers
|
|
)
|
|
assert exp_response.status_code == 201
|
|
expense_id = exp_response.json()["id"]
|
|
|
|
splits = await self._get_expense_splits(client, expense_id, user1_headers)
|
|
user2_split = next(s for s in splits if s["user_id"] == user2.id)
|
|
|
|
# User2 pays their full share (33.33) via SettlementActivity
|
|
await self._create_settlement_activity(
|
|
client, user2_split["id"], user2.id, user2_split["owed_amount"], user2_headers
|
|
)
|
|
|
|
# User3 then pays User1 30.00 via a generic Settlement
|
|
await self._create_generic_settlement(
|
|
client, group.id, user3.id, user1.id, "30.00", user3_headers
|
|
)
|
|
|
|
summary_response = await client.get(
|
|
f"{settings.API_V1_STR}/groups/{group.id}/balance-summary", headers=user1_headers
|
|
)
|
|
assert summary_response.status_code == 200
|
|
summary_data = summary_response.json()
|
|
user_balances = {ub["user_id"]: ub for ub in summary_data["user_balances"]}
|
|
|
|
# Expected balances:
|
|
# User1: Paid 100. Share 33.33. U2 SA clears U2's debt to U1. U3 pays U1 30 (Generic).
|
|
# total_paid_for_expenses = 100.00
|
|
# total_share_of_expenses = 33.33
|
|
# total_settlements_paid (generic) = 0.00
|
|
# total_settlements_received (generic) = 30.00
|
|
# Net: (100 + 30) - (33.33 + 0) = 130 - 33.33 = 96.67. This is U1's position.
|
|
# Overall group balance: U1 is owed 3.34 by U3. So U1 net is +3.34.
|
|
# User2: Share 33.33. Paid 33.33 via SA. Net = 0.
|
|
# total_paid_for_expenses = 0.00
|
|
# total_share_of_expenses = 0.00 (33.33 initial - 33.33 SA)
|
|
# total_settlements_paid (generic) = 0.00
|
|
# total_settlements_received (generic) = 0.00
|
|
# Net: 0.00
|
|
# User3: Share 33.34. Paid 30.00 via Generic Settlement to U1.
|
|
# total_paid_for_expenses = 0.00
|
|
# total_share_of_expenses = 33.34
|
|
# total_settlements_paid (generic) = 30.00
|
|
# total_settlements_received (generic) = 0.00
|
|
# Net: (0 + 0) - (33.34 + 30.00) = -63.34. This is U3's position.
|
|
# Overall group balance: U3 owes U1 3.34. So U3 net is -3.34.
|
|
# Sum = 3.34 + 0 - 3.34 = 0
|
|
|
|
# User1 assertions
|
|
assert user_balances[user1.id]["total_paid_for_expenses"] == "100.00"
|
|
assert user_balances[user1.id]["total_share_of_expenses"] == "33.33"
|
|
assert user_balances[user1.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user1.id]["total_settlements_received"] == "30.00"
|
|
assert user_balances[user1.id]["net_balance"] == "3.34" # (100+30) - (33.33) = 96.67 ... error in manual calc for net.
|
|
# Net = (paid_exp + generic_recv) - (adj_share + generic_paid)
|
|
# U1: (100 + 30) - (33.33 + 0) = 96.67. This is if there were no other users.
|
|
# The suggested settlement re-balances this.
|
|
# Net effect: U1 paid 100 for an expense. U1's share was 33.33. U2 paid their 33.33 share (to U1).
|
|
# U3's share was 33.34. U3 paid U1 30.00. So U3 still owes U1 3.34.
|
|
# So U1 is +3.34.
|
|
|
|
# User2 assertions
|
|
assert user_balances[user2.id]["total_paid_for_expenses"] == "0.00"
|
|
assert user_balances[user2.id]["total_share_of_expenses"] == "0.00"
|
|
assert user_balances[user2.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user2.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user2.id]["net_balance"] == "0.00"
|
|
|
|
# User3 assertions
|
|
assert user_balances[user3.id]["total_paid_for_expenses"] == "0.00"
|
|
assert user_balances[user3.id]["total_share_of_expenses"] == "33.34"
|
|
assert user_balances[user3.id]["total_settlements_paid"] == "30.00"
|
|
assert user_balances[user3.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user3.id]["net_balance"] == "-3.34" # (0+0) - (33.34+30) = -63.34.
|
|
# U3 owes 33.34 for expense. U3 paid U1 30. So U3 owes 3.34.
|
|
|
|
sum_net_balances = sum(Decimal(ub["net_balance"]) for ub in user_balances.values())
|
|
assert sum_net_balances == Decimal("0.00")
|
|
|
|
# Suggested settlements: User3 pays User1 3.34
|
|
suggested = summary_data["suggested_settlements"]
|
|
assert len(suggested) == 1
|
|
|
|
assert suggested[0]["from_user_id"] == user3.id
|
|
assert suggested[0]["to_user_id"] == user1.id
|
|
assert suggested[0]["amount"] == "3.34"
|
|
|
|
async def test_balance_summary_complex_scenario(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_user3_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
user2_headers = test_user2_api_costs["headers"]
|
|
user3 = test_user3_api_costs["user"]
|
|
user3_headers = test_user3_api_costs["headers"]
|
|
group = test_group_api_costs
|
|
|
|
# Expense 1: User1 pays 100. Split: U1=20, U2=40, U3=40.
|
|
exp1_payload = {
|
|
"description": "Complex Exp1", "total_amount": "100.00", "currency": "USD",
|
|
"group_id": group.id, "paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.EXACT_AMOUNTS.value,
|
|
"splits_in": [
|
|
{"user_id": user1.id, "owed_amount": "20.00"},
|
|
{"user_id": user2.id, "owed_amount": "40.00"},
|
|
{"user_id": user3.id, "owed_amount": "40.00"},
|
|
]
|
|
}
|
|
exp1_res = await client.post(f"{settings.API_V1_STR}/expenses/", json=exp1_payload, headers=user1_headers)
|
|
assert exp1_res.status_code == 201
|
|
exp1_id = exp1_res.json()["id"]
|
|
exp1_splits = await self._get_expense_splits(client, exp1_id, user1_headers)
|
|
u2_exp1_split = next(s for s in exp1_splits if s["user_id"] == user2.id)
|
|
u3_exp1_split = next(s for s in exp1_splits if s["user_id"] == user3.id)
|
|
|
|
# Expense 2: User2 pays 50. Split: U1=10, U2=20, U3=20.
|
|
exp2_payload = {
|
|
"description": "Complex Exp2", "total_amount": "50.00", "currency": "USD",
|
|
"group_id": group.id, "paid_by_user_id": user2.id,
|
|
"split_type": SplitTypeEnum.EXACT_AMOUNTS.value,
|
|
"splits_in": [
|
|
{"user_id": user1.id, "owed_amount": "10.00"},
|
|
{"user_id": user2.id, "owed_amount": "20.00"},
|
|
{"user_id": user3.id, "owed_amount": "20.00"},
|
|
]
|
|
}
|
|
exp2_res = await client.post(f"{settings.API_V1_STR}/expenses/", json=exp2_payload, headers=user2_headers)
|
|
assert exp2_res.status_code == 201
|
|
exp2_id = exp2_res.json()["id"]
|
|
exp2_splits = await self._get_expense_splits(client, exp2_id, user2_headers)
|
|
u1_exp2_split = next(s for s in exp2_splits if s["user_id"] == user1.id)
|
|
|
|
# Settlement Activities
|
|
# User2 pays 10 towards their share of Exp1 via SA.
|
|
await self._create_settlement_activity(client, u2_exp1_split["id"], user2.id, "10.00", user2_headers)
|
|
# User3 pays 20 towards their share of Exp1 via SA.
|
|
await self._create_settlement_activity(client, u3_exp1_split["id"], user3.id, "20.00", user3_headers)
|
|
# User1 pays 5 towards their share of Exp2 via SA.
|
|
await self._create_settlement_activity(client, u1_exp2_split["id"], user1.id, "5.00", user1_headers)
|
|
|
|
# Get balance summary
|
|
summary_response = await client.get(
|
|
f"{settings.API_V1_STR}/groups/{group.id}/balance-summary", headers=user1_headers
|
|
)
|
|
assert summary_response.status_code == 200
|
|
summary_data = summary_response.json()
|
|
user_balances = {ub["user_id"]: ub for ub in summary_data["user_balances"]}
|
|
|
|
# User1: total_paid_for_expenses=100. Initial Share (20+10)=30. SA paid by U1 for Exp2=5. Adjusted Share = 30-5=25. Net=+45
|
|
assert user_balances[user1.id]["total_paid_for_expenses"] == "100.00"
|
|
assert user_balances[user1.id]["total_share_of_expenses"] == "25.00"
|
|
assert user_balances[user1.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user1.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user1.id]["net_balance"] == "45.00"
|
|
|
|
# User2: total_paid_for_expenses=50. Initial Share (40+20)=60. SA paid by U2 for Exp1=10. Adjusted Share = 60-10=50. Net=-5
|
|
assert user_balances[user2.id]["total_paid_for_expenses"] == "50.00"
|
|
assert user_balances[user2.id]["total_share_of_expenses"] == "50.00"
|
|
assert user_balances[user2.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user2.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user2.id]["net_balance"] == "-5.00" # Corrected from 0 to -5 from manual calc
|
|
|
|
# User3: total_paid_for_expenses=0. Initial Share (40+20)=60. SA paid by U3 for Exp1=20. Adjusted Share = 60-20=40. Net=-40
|
|
assert user_balances[user3.id]["total_paid_for_expenses"] == "0.00"
|
|
assert user_balances[user3.id]["total_share_of_expenses"] == "40.00"
|
|
assert user_balances[user3.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user3.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user3.id]["net_balance"] == "-40.00"
|
|
|
|
sum_net_balances = sum(Decimal(ub["net_balance"]) for ub in user_balances.values())
|
|
assert sum_net_balances == Decimal("0.00")
|
|
|
|
# Suggested settlements: User2 pays User1 5.00, User3 pays User1 40.00
|
|
suggested = sorted(summary_data["suggested_settlements"], key=lambda s: s["from_user_id"])
|
|
assert len(suggested) == 2
|
|
|
|
assert suggested[0]["from_user_id"] == user2.id
|
|
assert suggested[0]["to_user_id"] == user1.id
|
|
assert suggested[0]["amount"] == "5.00"
|
|
|
|
assert suggested[1]["from_user_id"] == user3.id
|
|
assert suggested[1]["to_user_id"] == user1.id
|
|
assert suggested[1]["amount"] == "40.00"
|
|
|
|
async def test_balance_summary_full_settlement_activity_one_user(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_user3_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
user2_headers = test_user2_api_costs["headers"] # For User2 to make a settlement
|
|
user3 = test_user3_api_costs["user"]
|
|
group = test_group_api_costs
|
|
|
|
# Create an expense: User1 paid 100, split EQUAL among User1, User2, User3
|
|
expense_payload = {
|
|
"description": "Dinner - Full SA by User2",
|
|
"total_amount": "100.00",
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.EQUAL.value,
|
|
}
|
|
exp_response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/", json=expense_payload, headers=user1_headers
|
|
)
|
|
assert exp_response.status_code == 201
|
|
expense_id = exp_response.json()["id"]
|
|
|
|
# Get splits to find User2's split_id
|
|
splits = await self._get_expense_splits(client, expense_id, user1_headers)
|
|
user2_split = next(s for s in splits if s["user_id"] == user2.id)
|
|
assert user2_split["owed_amount"] == "33.33" # From EQUAL split
|
|
|
|
# User2 pays their full share via SettlementActivity
|
|
await self._create_settlement_activity(
|
|
client, user2_split["id"], user2.id, user2_split["owed_amount"], user2_headers
|
|
)
|
|
|
|
# Get balance summary
|
|
summary_response = await client.get(
|
|
f"{settings.API_V1_STR}/groups/{group.id}/balance-summary", headers=user1_headers
|
|
)
|
|
assert summary_response.status_code == 200
|
|
summary_data = summary_response.json()
|
|
user_balances = {ub["user_id"]: ub for ub in summary_data["user_balances"]}
|
|
|
|
# Expected:
|
|
# User1: Paid 100. Initial Share 33.33. User2 paid their 33.33. U1 is now owed 33.34 by U3.
|
|
# total_paid_for_expenses = 100.00
|
|
# adjusted_total_share_of_expenses = 33.33 (own share, not affected by U2's SA payment)
|
|
# net_balance = (100.00 + 0) - (33.33 + 0) = 66.67. This is before considering who owes whom.
|
|
# The system calculates: User1 is owed 33.34 by User3. User2 is settled. So User1 is +33.34.
|
|
# User2: Paid 0 for expenses. Initial Share 33.33. Paid 33.33 via SA.
|
|
# total_paid_for_expenses = 0.00
|
|
# adjusted_total_share_of_expenses = 33.33 - 33.33 = 0.00
|
|
# net_balance = (0 + 0) - (0 + 0) = 0.00
|
|
# User3: Paid 0 for expenses. Initial Share 33.34. Paid 0.
|
|
# total_paid_for_expenses = 0.00
|
|
# adjusted_total_share_of_expenses = 33.34
|
|
# net_balance = (0 + 0) - (33.34 + 0) = -33.34
|
|
# Sum = 0
|
|
|
|
# User1 assertions
|
|
assert user_balances[user1.id]["total_paid_for_expenses"] == "100.00"
|
|
assert user_balances[user1.id]["total_share_of_expenses"] == "33.33"
|
|
assert user_balances[user1.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user1.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user1.id]["net_balance"] == "33.34"
|
|
|
|
# User2 assertions
|
|
assert user_balances[user2.id]["total_paid_for_expenses"] == "0.00"
|
|
assert user_balances[user2.id]["total_share_of_expenses"] == "0.00"
|
|
assert user_balances[user2.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user2.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user2.id]["net_balance"] == "0.00"
|
|
|
|
# User3 assertions
|
|
assert user_balances[user3.id]["total_paid_for_expenses"] == "0.00"
|
|
assert user_balances[user3.id]["total_share_of_expenses"] == "33.34"
|
|
assert user_balances[user3.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user3.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user3.id]["net_balance"] == "-33.34"
|
|
|
|
sum_net_balances = sum(Decimal(ub["net_balance"]) for ub in user_balances.values())
|
|
assert sum_net_balances == Decimal("0.00")
|
|
|
|
# Suggested settlements: User3 pays User1 33.34
|
|
suggested = summary_data["suggested_settlements"]
|
|
assert len(suggested) == 1
|
|
|
|
assert suggested[0]["from_user_id"] == user3.id
|
|
assert suggested[0]["to_user_id"] == user1.id
|
|
assert suggested[0]["amount"] == "33.34"
|
|
|
|
async def test_balance_summary_partial_settlement_activity(
|
|
self,
|
|
client: httpx.AsyncClient,
|
|
test_user1_api_costs: Dict[str, Any],
|
|
test_user2_api_costs: Dict[str, Any],
|
|
test_user3_api_costs: Dict[str, Any],
|
|
test_group_api_costs: Group,
|
|
):
|
|
user1 = test_user1_api_costs["user"]
|
|
user1_headers = test_user1_api_costs["headers"]
|
|
user2 = test_user2_api_costs["user"]
|
|
user2_headers = test_user2_api_costs["headers"]
|
|
user3 = test_user3_api_costs["user"]
|
|
group = test_group_api_costs
|
|
|
|
# Create an expense: User1 paid 100, split EQUAL among User1, User2, User3
|
|
expense_payload = {
|
|
"description": "Dinner - Partial SA by User2",
|
|
"total_amount": "100.00",
|
|
"currency": "USD",
|
|
"group_id": group.id,
|
|
"paid_by_user_id": user1.id,
|
|
"split_type": SplitTypeEnum.EQUAL.value,
|
|
}
|
|
exp_response = await client.post(
|
|
f"{settings.API_V1_STR}/expenses/", json=expense_payload, headers=user1_headers
|
|
)
|
|
assert exp_response.status_code == 201
|
|
expense_id = exp_response.json()["id"]
|
|
|
|
splits = await self._get_expense_splits(client, expense_id, user1_headers)
|
|
user2_split = next(s for s in splits if s["user_id"] == user2.id)
|
|
assert user2_split["owed_amount"] == "33.33"
|
|
|
|
# User2 pays 10.00 of their 33.33 share via SettlementActivity
|
|
await self._create_settlement_activity(
|
|
client, user2_split["id"], user2.id, "10.00", user2_headers
|
|
)
|
|
|
|
summary_response = await client.get(
|
|
f"{settings.API_V1_STR}/groups/{group.id}/balance-summary", headers=user1_headers
|
|
)
|
|
assert summary_response.status_code == 200
|
|
summary_data = summary_response.json()
|
|
user_balances = {ub["user_id"]: ub for ub in summary_data["user_balances"]}
|
|
|
|
# Expected balances:
|
|
# User1: Paid 100. Share 33.33. Effectively received 10 from User2. Net: +56.67
|
|
# User2: Share 33.33. Paid 10.00 via SA. Adjusted Share: 23.33. Net: -23.33
|
|
# User3: Share 33.34. Paid 0. Net: -33.34
|
|
# Sum = 56.67 - 23.33 - 33.34 = 0
|
|
|
|
# User1 assertions
|
|
assert user_balances[user1.id]["total_paid_for_expenses"] == "100.00"
|
|
assert user_balances[user1.id]["total_share_of_expenses"] == "33.33"
|
|
assert user_balances[user1.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user1.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user1.id]["net_balance"] == "56.67"
|
|
|
|
# User2 assertions
|
|
assert user_balances[user2.id]["total_paid_for_expenses"] == "0.00"
|
|
assert user_balances[user2.id]["total_share_of_expenses"] == "23.33" # 33.33 initial - 10.00 SA
|
|
assert user_balances[user2.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user2.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user2.id]["net_balance"] == "-23.33"
|
|
|
|
# User3 assertions
|
|
assert user_balances[user3.id]["total_paid_for_expenses"] == "0.00"
|
|
assert user_balances[user3.id]["total_share_of_expenses"] == "33.34"
|
|
assert user_balances[user3.id]["total_settlements_paid"] == "0.00"
|
|
assert user_balances[user3.id]["total_settlements_received"] == "0.00"
|
|
assert user_balances[user3.id]["net_balance"] == "-33.34"
|
|
|
|
sum_net_balances = sum(Decimal(ub["net_balance"]) for ub in user_balances.values())
|
|
assert sum_net_balances == Decimal("0.00")
|
|
|
|
# Suggested settlements: User2 pays User1 23.33, User3 pays User1 33.34
|
|
suggested = sorted(summary_data["suggested_settlements"], key=lambda s: (s["from_user_id"], s["amount"]))
|
|
assert len(suggested) == 2
|
|
|
|
assert suggested[0]["from_user_id"] == user2.id
|
|
assert suggested[0]["to_user_id"] == user1.id
|
|
assert suggested[0]["amount"] == "23.33"
|
|
|
|
assert suggested[1]["from_user_id"] == user3.id
|
|
assert suggested[1]["to_user_id"] == user1.id
|
|
assert suggested[1]["amount"] == "33.34"
|