import pytest from unittest.mock import AsyncMock, MagicMock, patch from sqlalchemy.exc import IntegrityError, OperationalError from sqlalchemy.future import select from decimal import Decimal, ROUND_HALF_UP from datetime import datetime, timezone from typing import List as PyList from app.crud.settlement import ( create_settlement, get_settlement_by_id, get_settlements_for_group, get_settlements_involving_user, update_settlement, delete_settlement ) from app.schemas.expense import SettlementCreate, SettlementUpdate from app.models import Settlement as SettlementModel, User as UserModel, Group as GroupModel from app.core.exceptions import UserNotFoundError, GroupNotFoundError, InvalidOperationError # Fixtures @pytest.fixture def mock_db_session(): session = AsyncMock() session.commit = AsyncMock() session.rollback = AsyncMock() session.refresh = AsyncMock() session.add = MagicMock() session.delete = MagicMock() session.execute = AsyncMock() session.get = AsyncMock() return session @pytest.fixture def settlement_create_data(): return SettlementCreate( group_id=1, paid_by_user_id=1, paid_to_user_id=2, amount=Decimal("10.50"), settlement_date=datetime.now(timezone.utc), description="Test settlement" ) @pytest.fixture def settlement_update_data(): return SettlementUpdate( description="Updated settlement description", settlement_date=datetime.now(timezone.utc), version=1 # Assuming version is required for update ) @pytest.fixture def db_settlement_model(): return SettlementModel( id=1, group_id=1, paid_by_user_id=1, paid_to_user_id=2, amount=Decimal("10.50"), settlement_date=datetime.now(timezone.utc), description="Original settlement", created_by_user_id=1, version=1, # Initial version created_at=datetime.now(timezone.utc), updated_at=datetime.now(timezone.utc), payer=UserModel(id=1, name="Payer User"), payee=UserModel(id=2, name="Payee User"), group=GroupModel(id=1, name="Test Group"), created_by_user=UserModel(id=1, name="Payer User") # Same as payer for simplicity ) @pytest.fixture def payer_user_model(): return UserModel(id=1, name="Payer User", email="payer@example.com") @pytest.fixture def payee_user_model(): return UserModel(id=2, name="Payee User", email="payee@example.com") @pytest.fixture def group_model(): return GroupModel(id=1, name="Test Group") # Tests for create_settlement @pytest.mark.asyncio async def test_create_settlement_success(mock_db_session, settlement_create_data, payer_user_model, payee_user_model, group_model): mock_db_session.get.side_effect = [payer_user_model, payee_user_model, group_model] # Order of gets created_settlement = await create_settlement(mock_db_session, settlement_create_data, current_user_id=1) mock_db_session.add.assert_called_once() mock_db_session.commit.assert_called_once() mock_db_session.refresh.assert_called_once() assert created_settlement is not None assert created_settlement.amount == settlement_create_data.amount.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP) assert created_settlement.paid_by_user_id == settlement_create_data.paid_by_user_id assert created_settlement.paid_to_user_id == settlement_create_data.paid_to_user_id @pytest.mark.asyncio async def test_create_settlement_payer_not_found(mock_db_session, settlement_create_data): mock_db_session.get.side_effect = [None, payee_user_model, group_model] with pytest.raises(UserNotFoundError) as excinfo: await create_settlement(mock_db_session, settlement_create_data, 1) assert "Payer" in str(excinfo.value) @pytest.mark.asyncio async def test_create_settlement_payee_not_found(mock_db_session, settlement_create_data, payer_user_model): mock_db_session.get.side_effect = [payer_user_model, None, group_model] with pytest.raises(UserNotFoundError) as excinfo: await create_settlement(mock_db_session, settlement_create_data, 1) assert "Payee" in str(excinfo.value) @pytest.mark.asyncio async def test_create_settlement_group_not_found(mock_db_session, settlement_create_data, payer_user_model, payee_user_model): mock_db_session.get.side_effect = [payer_user_model, payee_user_model, None] with pytest.raises(GroupNotFoundError): await create_settlement(mock_db_session, settlement_create_data, 1) @pytest.mark.asyncio async def test_create_settlement_payer_equals_payee(mock_db_session, settlement_create_data, payer_user_model, group_model): settlement_create_data.paid_to_user_id = settlement_create_data.paid_by_user_id mock_db_session.get.side_effect = [payer_user_model, payer_user_model, group_model] with pytest.raises(InvalidOperationError) as excinfo: await create_settlement(mock_db_session, settlement_create_data, 1) assert "Payer and Payee cannot be the same user" in str(excinfo.value) @pytest.mark.asyncio async def test_create_settlement_commit_failure(mock_db_session, settlement_create_data, payer_user_model, payee_user_model, group_model): mock_db_session.get.side_effect = [payer_user_model, payee_user_model, group_model] mock_db_session.commit.side_effect = Exception("DB commit failed") with pytest.raises(InvalidOperationError) as excinfo: await create_settlement(mock_db_session, settlement_create_data, 1) assert "Failed to save settlement" in str(excinfo.value) mock_db_session.rollback.assert_called_once() # Tests for get_settlement_by_id @pytest.mark.asyncio async def test_get_settlement_by_id_found(mock_db_session, db_settlement_model): mock_db_session.execute.return_value.scalars.return_value.first.return_value = db_settlement_model settlement = await get_settlement_by_id(mock_db_session, 1) assert settlement is not None assert settlement.id == 1 mock_db_session.execute.assert_called_once() @pytest.mark.asyncio async def test_get_settlement_by_id_not_found(mock_db_session): mock_db_session.execute.return_value.scalars.return_value.first.return_value = None settlement = await get_settlement_by_id(mock_db_session, 999) assert settlement is None # Tests for get_settlements_for_group @pytest.mark.asyncio async def test_get_settlements_for_group_success(mock_db_session, db_settlement_model): mock_db_session.execute.return_value.scalars.return_value.all.return_value = [db_settlement_model] settlements = await get_settlements_for_group(mock_db_session, group_id=1) assert len(settlements) == 1 assert settlements[0].group_id == 1 mock_db_session.execute.assert_called_once() # Tests for get_settlements_involving_user @pytest.mark.asyncio async def test_get_settlements_involving_user_success(mock_db_session, db_settlement_model): mock_db_session.execute.return_value.scalars.return_value.all.return_value = [db_settlement_model] settlements = await get_settlements_involving_user(mock_db_session, user_id=1) assert len(settlements) == 1 assert settlements[0].paid_by_user_id == 1 or settlements[0].paid_to_user_id == 1 mock_db_session.execute.assert_called_once() @pytest.mark.asyncio async def test_get_settlements_involving_user_with_group_filter(mock_db_session, db_settlement_model): mock_db_session.execute.return_value.scalars.return_value.all.return_value = [db_settlement_model] settlements = await get_settlements_involving_user(mock_db_session, user_id=1, group_id=1) assert len(settlements) == 1 # More specific assertions about the query would require deeper mocking of SQLAlchemy query construction mock_db_session.execute.assert_called_once() # Tests for update_settlement @pytest.mark.asyncio async def test_update_settlement_success(mock_db_session, db_settlement_model, settlement_update_data): # Ensure settlement_update_data.version matches db_settlement_model.version settlement_update_data.version = db_settlement_model.version # Mock datetime.now() fixed_datetime_now = datetime.now(timezone.utc) with patch('app.crud.settlement.datetime', wraps=datetime) as mock_datetime: mock_datetime.now.return_value = fixed_datetime_now updated_settlement = await update_settlement(mock_db_session, db_settlement_model, settlement_update_data) mock_db_session.commit.assert_called_once() mock_db_session.refresh.assert_called_once() assert updated_settlement.description == settlement_update_data.description assert updated_settlement.settlement_date == settlement_update_data.settlement_date assert updated_settlement.version == db_settlement_model.version + 1 # Version incremented assert updated_settlement.updated_at == fixed_datetime_now @pytest.mark.asyncio async def test_update_settlement_version_mismatch(mock_db_session, db_settlement_model, settlement_update_data): settlement_update_data.version = db_settlement_model.version + 1 # Mismatched version with pytest.raises(InvalidOperationError) as excinfo: await update_settlement(mock_db_session, db_settlement_model, settlement_update_data) assert "version does not match" in str(excinfo.value) @pytest.mark.asyncio async def test_update_settlement_disallowed_field(mock_db_session, db_settlement_model): # Create an update payload with a field not allowed to be updated, e.g., 'amount' invalid_update_data = SettlementUpdate(amount=Decimal("100.00"), version=db_settlement_model.version) with pytest.raises(InvalidOperationError) as excinfo: await update_settlement(mock_db_session, db_settlement_model, invalid_update_data) assert "Field 'amount' cannot be updated" in str(excinfo.value) @pytest.mark.asyncio async def test_update_settlement_commit_failure(mock_db_session, db_settlement_model, settlement_update_data): settlement_update_data.version = db_settlement_model.version mock_db_session.commit.side_effect = Exception("DB commit failed") with pytest.raises(InvalidOperationError) as excinfo: await update_settlement(mock_db_session, db_settlement_model, settlement_update_data) assert "Failed to update settlement" in str(excinfo.value) mock_db_session.rollback.assert_called_once() # Tests for delete_settlement @pytest.mark.asyncio async def test_delete_settlement_success(mock_db_session, db_settlement_model): await delete_settlement(mock_db_session, db_settlement_model) mock_db_session.delete.assert_called_once_with(db_settlement_model) mock_db_session.commit.assert_called_once() @pytest.mark.asyncio async def test_delete_settlement_success_with_version_check(mock_db_session, db_settlement_model): await delete_settlement(mock_db_session, db_settlement_model, expected_version=db_settlement_model.version) mock_db_session.delete.assert_called_once_with(db_settlement_model) mock_db_session.commit.assert_called_once() @pytest.mark.asyncio async def test_delete_settlement_version_mismatch(mock_db_session, db_settlement_model): with pytest.raises(InvalidOperationError) as excinfo: await delete_settlement(mock_db_session, db_settlement_model, expected_version=db_settlement_model.version + 1) assert "Expected version" in str(excinfo.value) assert "does not match current version" in str(excinfo.value) mock_db_session.delete.assert_not_called() @pytest.mark.asyncio async def test_delete_settlement_commit_failure(mock_db_session, db_settlement_model): mock_db_session.commit.side_effect = Exception("DB commit failed") with pytest.raises(InvalidOperationError) as excinfo: await delete_settlement(mock_db_session, db_settlement_model) assert "Failed to delete settlement" in str(excinfo.value) mock_db_session.rollback.assert_called_once()