events/tests/test_promo_api.py

from datetime import datetime, timezone
from types import SimpleNamespace
from unittest.mock import AsyncMock

import pytest
from fastapi import HTTPException

from .. import views_api
from ..models import CreateTicket, Event, EventExtra, PromoCode, PromoValidateRequest


def _event(codes) -> Event:
    return Event(
        id="evt",
        wallet="w",
        name="Test",
        info="",
        closing_date="2030-01-01",
        event_start_date="2030-01-01",
        event_end_date="2030-01-02",
        currency="sat",
        price_per_ticket=1000,
        amount_tickets=10,
        time=datetime.now(timezone.utc),
        extra=EventExtra(promo_codes=codes),
        status="approved",
    )


@pytest.fixture
def event(monkeypatch):
    ev = _event(
        [
            PromoCode(code="HALF", discount_percent=50, max_uses=2),
            PromoCode(code="OLD", discount_percent=20, active=False),
        ]
    )
    monkeypatch.setattr(views_api, "get_event", AsyncMock(return_value=ev))
    monkeypatch.setattr(
        views_api, "event_promo_usage", AsyncMock(return_value={"HALF": 1})
    )
    return ev


@pytest.mark.asyncio
async def test_validate_returns_v2_shaped_totals(event):
    totals = await views_api.api_validate_promo_codes(
        "evt", PromoValidateRequest(codes=["half"], quantity=1)
    )
    assert totals.dict() == {
        "subtotal": 1000,
        "discount": 500,
        "total": 500,
        "currency": "sat",
        "discounts_applied": [
            {
                "code": "HALF",
                "discount_percent": 50,
                "discount_fixed": None,
                "amount_saved": 500,
            }
        ],
    }


@pytest.mark.asyncio
async def test_validate_is_advisory_for_bad_codes(event):
    for codes, qty in ((["OLD"], 1), (["NOPE"], 1), (["HALF"], 2)):
        totals = await views_api.api_validate_promo_codes(
            "evt", PromoValidateRequest(codes=codes, quantity=qty)
        )
        assert totals.discounts_applied == [] and totals.total == totals.subtotal


@pytest.mark.asyncio
async def test_validate_unknown_event_is_404(monkeypatch):
    monkeypatch.setattr(views_api, "get_event", AsyncMock(return_value=None))
    with pytest.raises(HTTPException) as exc:
        await views_api.api_validate_promo_codes(
            "nope", PromoValidateRequest(codes=["X"])
        )
    assert exc.value.status_code == 404


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "code,quantity,detail",
    [
        ("NOPE", 1, "Invalid promo code."),
        ("old", 1, "Promo code is not active."),
        ("HALF", 2, "Only 1 use(s) left on this promo code."),
    ],
)
async def test_purchase_rejects_bad_codes_before_any_invoice(
    event, monkeypatch, code, quantity, detail
):
    monkeypatch.setattr(
        views_api,
        "create_payment_request",
        AsyncMock(side_effect=AssertionError("must not be called")),
    )
    data = CreateTicket(user_id="u1", promo_code=code, quantity=quantity)
    with pytest.raises(HTTPException) as exc:
        await views_api.api_ticket_create(
            "evt", data, SimpleNamespace(base_url="http://lnbits.local/")
        )
    assert exc.value.status_code == 400
    assert exc.value.detail == detail


@pytest.mark.asyncio
async def test_purchase_reports_fully_redeemed(event, monkeypatch):
    monkeypatch.setattr(
        views_api, "event_promo_usage", AsyncMock(return_value={"HALF": 2})
    )
    monkeypatch.setattr(
        views_api,
        "create_payment_request",
        AsyncMock(side_effect=AssertionError("must not be called")),
    )
    with pytest.raises(HTTPException) as exc:
        await views_api.api_ticket_create(
            "evt",
            CreateTicket(user_id="u1", promo_code="HALF"),
            SimpleNamespace(base_url="http://lnbits.local/"),
        )
    assert exc.value.detail == "Promo code has been fully redeemed."


@pytest.fixture
def update_env(monkeypatch):
    stored = _event([PromoCode(code="KEEP", discount_percent=10)])
    monkeypatch.setattr(views_api, "get_event", AsyncMock(return_value=stored))
    monkeypatch.setattr(
        views_api,
        "get_settings",
        AsyncMock(return_value=SimpleNamespace(auto_approve=True)),
    )
    monkeypatch.setattr(views_api, "update_event", AsyncMock(side_effect=lambda e: e))
    monkeypatch.setattr(views_api, "publish_or_delete_nostr_event", AsyncMock())
    return stored


def _update_payload(extra: dict) -> dict:
    return {
        "wallet": "w",
        "name": "Test",
        "info": "",
        "closing_date": "2030-01-01",
        "event_start_date": "2030-01-01",
        "event_end_date": "2030-01-02",
        "amount_tickets": 10,
        "price_per_ticket": 1000,
        "extra": extra,
    }


def _wallet():
    return SimpleNamespace(wallet=SimpleNamespace(id="w", user="u1"))


@pytest.mark.asyncio
async def test_update_without_promo_key_keeps_stored_codes(update_env):
    from ..models import CreateEvent

    data = CreateEvent.parse_obj(_update_payload({"email_notifications": True}))
    event = await views_api.api_event_update("evt", data, _wallet())
    assert [pc.code for pc in event.extra.promo_codes] == ["KEEP"]
    assert event.extra.email_notifications is True


@pytest.mark.asyncio
async def test_update_with_empty_promo_list_clears(update_env):
    from ..models import CreateEvent

    data = CreateEvent.parse_obj(_update_payload({"promo_codes": []}))
    event = await views_api.api_event_update("evt", data, _wallet())
    assert event.extra.promo_codes == []