TimeTracker/tests/test_payment_model.py

"""Tests for Payment model"""

import pytest
from datetime import datetime, date, timedelta
from decimal import Decimal
from app import db, create_app
from sqlalchemy.pool import StaticPool
from app.models import Payment, Invoice, User, Project, Client
from factories import UserFactory, ClientFactory, ProjectFactory, InvoiceFactory, PaymentFactory


@pytest.fixture
def app():
    """Isolated app for payment model tests using in-memory SQLite to avoid file locks on Windows."""
    app = create_app(
        {
            "TESTING": True,
            "SQLALCHEMY_DATABASE_URI": "sqlite://",
            "WTF_CSRF_ENABLED": False,
            "SQLALCHEMY_ENGINE_OPTIONS": {
                "connect_args": {"check_same_thread": False, "timeout": 30},
                "poolclass": StaticPool,
            },
            "SQLALCHEMY_SESSION_OPTIONS": {"expire_on_commit": False},
        }
    )
    with app.app_context():
        db.create_all()
        try:
            # Improve SQLite concurrency behavior
            db.session.execute("PRAGMA journal_mode=WAL;")
            db.session.execute("PRAGMA synchronous=NORMAL;")
            db.session.execute("PRAGMA busy_timeout=30000;")
            db.session.commit()
        except Exception:
            db.session.rollback()
        try:
            yield app
        finally:
            db.session.remove()
            db.drop_all()
            try:
                db.engine.dispose()
            except Exception:
                pass


@pytest.fixture
def test_user(app):
    """Create a test user"""
    with app.app_context():
        user = UserFactory()
        yield user


@pytest.fixture
def test_client(app):
    """Create a test client"""
    with app.app_context():
        client = ClientFactory()
        yield client


@pytest.fixture
def test_project(app, test_client, test_user):
    """Create a test project"""
    with app.app_context():
        project = ProjectFactory(client_id=test_client.id, billable=True, hourly_rate=Decimal("100.00"))
        yield project


@pytest.fixture
def test_invoice(app, test_project, test_user, test_client):
    """Create a test invoice"""
    with app.app_context():
        invoice = InvoiceFactory(
            project_id=test_project.id,
            client_id=test_client.id,
            created_by=test_user.id,
            client_name="Test Client",
            due_date=(date.today() + timedelta(days=30)),
        )
        # Ensure non-zero totals for payment-related assertions
        invoice.subtotal = Decimal("1000.00")
        invoice.tax_rate = Decimal("21.00")
        invoice.tax_amount = Decimal("210.00")
        invoice.total_amount = Decimal("1210.00")
        db.session.add(invoice)
        db.session.commit()
        yield invoice


class TestPaymentModel:
    """Test Payment model functionality"""

    def test_create_payment(self, app, test_invoice, test_user):
        """Test creating a payment"""
        with app.app_context():
            payment = PaymentFactory(
                invoice_id=test_invoice.id,
                amount=Decimal("500.00"),
                currency="EUR",
                payment_date=date.today(),
                method="bank_transfer",
                reference="REF-12345",
                notes="Test payment",
                status="completed",
                received_by=test_user.id,
            )

            db.session.add(payment)
            db.session.commit()

            # Verify payment was created
            assert payment.id is not None
            assert payment.amount == Decimal("500.00")
            assert payment.currency == "EUR"
            assert payment.method == "bank_transfer"
            assert payment.status == "completed"

            # Cleanup
            db.session.delete(payment)
            db.session.commit()

    def test_payment_calculate_net_amount_without_fee(self, app, test_invoice):
        """Test calculating net amount without gateway fee"""
        with app.app_context():
            payment = PaymentFactory(
                invoice_id=test_invoice.id,
                amount=Decimal("500.00"),
                currency="EUR",
                payment_date=date.today(),
                status="completed",
            )

            payment.calculate_net_amount()

            assert payment.net_amount == Decimal("500.00")

            # Cleanup (not in DB yet, so no cleanup needed)

    def test_payment_calculate_net_amount_with_fee(self, app, test_invoice):
        """Test calculating net amount with gateway fee"""
        with app.app_context():
            payment = PaymentFactory(
                invoice_id=test_invoice.id,
                amount=Decimal("500.00"),
                currency="EUR",
                payment_date=date.today(),
                gateway_fee=Decimal("15.00"),
                status="completed",
            )

            payment.calculate_net_amount()

            assert payment.net_amount == Decimal("485.00")

    def test_payment_to_dict(self, app, test_invoice, test_user):
        """Test converting payment to dictionary"""
        with app.app_context():
            payment = PaymentFactory(
                invoice_id=test_invoice.id,
                amount=Decimal("500.00"),
                currency="EUR",
                payment_date=date.today(),
                method="bank_transfer",
                reference="REF-12345",
                notes="Test payment",
                status="completed",
                received_by=test_user.id,
                gateway_fee=Decimal("15.00"),
                # created_at/updated_at set by defaults; no need to override
            )
            payment.calculate_net_amount()

            db.session.add(payment)
            db.session.commit()

            payment_dict = payment.to_dict()

            assert payment_dict["invoice_id"] == test_invoice.id
            assert payment_dict["amount"] == 500.0
            assert payment_dict["currency"] == "EUR"
            assert payment_dict["method"] == "bank_transfer"
            assert payment_dict["reference"] == "REF-12345"
            assert payment_dict["status"] == "completed"
            assert payment_dict["gateway_fee"] == 15.0
            assert payment_dict["net_amount"] == 485.0

            # Cleanup
            db.session.delete(payment)
            db.session.commit()

    def test_payment_relationship_with_invoice(self, app, test_invoice):
        """Test payment relationship with invoice"""
        with app.app_context():
            # Re-query invoice to attach to current session
            from app.models.invoice import Invoice

            invoice_in_session = Invoice.query.get(test_invoice.id)

            payment = PaymentFactory(
                invoice_id=invoice_in_session.id,
                amount=Decimal("500.00"),
                currency="EUR",
                payment_date=date.today(),
                status="completed",
            )

            db.session.add(payment)
            db.session.commit()

            # Refresh invoice to get updated relationships
            db.session.refresh(invoice_in_session)

            # Verify relationship
            assert payment.invoice == invoice_in_session
            assert payment in invoice_in_session.payments

            # Cleanup
            db.session.delete(payment)
            db.session.commit()

    def test_payment_relationship_with_user(self, app, test_invoice, test_user):
        """Test payment relationship with user (receiver)"""
        with app.app_context():
            # Re-query user to attach to current session
            from app.models.user import User

            user_in_session = User.query.get(test_user.id)

            payment = PaymentFactory(
                invoice_id=test_invoice.id,
                amount=Decimal("500.00"),
                currency="EUR",
                payment_date=date.today(),
                status="completed",
                received_by=user_in_session.id,
            )

            db.session.add(payment)
            db.session.commit()

            # Refresh user to get updated relationships
            db.session.refresh(user_in_session)

            # Verify relationship
            assert payment.receiver == user_in_session
            assert payment in user_in_session.received_payments

            # Cleanup
            db.session.delete(payment)
            db.session.commit()

    def test_payment_repr(self, app, test_invoice):
        """Test payment string representation"""
        with app.app_context():
            payment = PaymentFactory(
                invoice_id=test_invoice.id,
                amount=Decimal("500.00"),
                currency="EUR",
                payment_date=date.today(),
                status="completed",
            )

            repr_str = repr(payment)
            assert "Payment" in repr_str
            assert "500.00" in repr_str
            assert "EUR" in repr_str

    def test_multiple_payments_for_invoice(self, app, test_invoice):
        """Test multiple payments for a single invoice"""
        with app.app_context():
            # Re-query invoice to attach to current session
            from app.models.invoice import Invoice

            invoice_in_session = Invoice.query.get(test_invoice.id)

            payment1 = PaymentFactory(
                invoice_id=invoice_in_session.id,
                amount=Decimal("300.00"),
                currency="EUR",
                payment_date=date.today(),
                status="completed",
            )

            payment2 = PaymentFactory(
                invoice_id=invoice_in_session.id,
                amount=Decimal("200.00"),
                currency="EUR",
                payment_date=date.today() + timedelta(days=1),
                status="completed",
            )

            db.session.add_all([payment1, payment2])
            db.session.commit()

            # Refresh invoice to get updated relationships
            db.session.refresh(invoice_in_session)

            # Verify both payments are associated with invoice
            assert invoice_in_session.payments.count() == 2

            # Cleanup
            db.session.delete(payment1)
            db.session.delete(payment2)
            db.session.commit()

    def test_payment_status_values(self, app, test_invoice):
        """Test different payment status values"""
        with app.app_context():
            statuses = ["completed", "pending", "failed", "refunded"]

            for status in statuses:
                payment = PaymentFactory(
                    invoice_id=test_invoice.id,
                    amount=Decimal("100.00"),
                    currency="EUR",
                    payment_date=date.today(),
                    status=status,
                )

                db.session.add(payment)
                db.session.commit()

                assert payment.status == status

                # Cleanup
                db.session.delete(payment)
                db.session.commit()


class TestPaymentIntegration:
    """Test Payment model integration with Invoice"""

    def test_invoice_updates_with_payment(self, app, test_invoice):
        """Test that invoice updates correctly when payment is added"""
        with app.app_context():
            # Initial state
            assert test_invoice.amount_paid == Decimal("0")
            assert test_invoice.payment_status == "unpaid"

            # Add payment
            payment = PaymentFactory(
                invoice_id=test_invoice.id,
                amount=Decimal("605.00"),  # Half of total
                currency="EUR",
                payment_date=date.today(),
                status="completed",
            )

            db.session.add(payment)

            # Update invoice manually (this would be done by route logic)
            test_invoice.amount_paid = (test_invoice.amount_paid or Decimal("0")) + payment.amount
            test_invoice.update_payment_status()

            db.session.commit()

            # Verify invoice was updated
            assert test_invoice.amount_paid == Decimal("605.00")
            assert test_invoice.payment_status == "partially_paid"

            # Cleanup
            db.session.delete(payment)
            test_invoice.amount_paid = Decimal("0")
            test_invoice.update_payment_status()
            db.session.commit()

    def test_invoice_fully_paid_with_payments(self, app, test_invoice):
        """Test that invoice becomes fully paid when total payments equal total amount"""
        with app.app_context():
            # Add payments that equal total amount
            payment = PaymentFactory(
                invoice_id=test_invoice.id,
                amount=test_invoice.total_amount,
                currency="EUR",
                payment_date=date.today(),
                status="completed",
            )

            db.session.add(payment)

            # Update invoice manually (this would be done by route logic)
            test_invoice.amount_paid = payment.amount
            test_invoice.update_payment_status()

            db.session.commit()

            # Verify invoice is fully paid
            assert test_invoice.payment_status == "fully_paid"
            assert test_invoice.is_paid is True

            # Cleanup
            db.session.delete(payment)
            test_invoice.amount_paid = Decimal("0")
            test_invoice.update_payment_status()
            db.session.commit()