Skip to content

armgit / mwmbl

Public Imported from GitHub
0

An open source, non-profit web search engine

29.1 KB
Raw Blame
"""
Tests for supporter membership endpoints.

Covers:
- GET /api/v1/platform/membership/tiers
- GET /api/v1/platform/membership
- POST /api/v1/platform/membership/checkout
- POST /api/v1/platform/membership/cancel and /uncancel
- POST /api/v1/platform/membership/change
- Membership subscription events on POST /api/v1/platform/billing/webhook
"""

from datetime import datetime, timezone
from unittest.mock import Mock, patch

import pytest
from allauth.account.models import EmailAddress
from django.contrib.auth import get_user_model
from django.test import Client, override_settings
from ninja_jwt.tokens import RefreshToken
from polar_sdk.models import AlreadyCanceledSubscription, SubscriptionLocked

from mwmbl.membership import MembershipTier
from mwmbl.models import Membership, UserBilling

User = get_user_model()

PRODUCT_SETTINGS = override_settings(
    POLAR_PRODUCT_ID_USAGE="prod_usage",
    POLAR_PRODUCT_ID_SPROUT="prod_sprout",
    POLAR_PRODUCT_ID_SAPLING="prod_sapling",
    POLAR_PRODUCT_ID_CANOPY="prod_canopy",
)


@pytest.fixture
def user(db):
    user = User.objects.create_user(username="memberuser", email="[email protected]", password="testpass123")
    EmailAddress.objects.create(user=user, email="[email protected]", verified=True, primary=True)
    return user


@pytest.fixture
def api_client(db):
    return Client()


def auth_headers(user):
    token = RefreshToken.for_user(user).access_token
    return {"HTTP_AUTHORIZATION": f"Bearer {token}"}


def _membership_event(event_type, user_id, product_id="prod_sapling", status="active", **data_overrides):
    event = Mock()
    event.TYPE = event_type
    event.data = Mock()
    event.data.metadata = {"user_id": str(user_id)}
    event.data.product_id = product_id
    event.data.status = status
    event.data.id = data_overrides.get("subscription_id", "sub_member")
    event.data.customer_id = "cust_member"
    event.data.current_period_end = data_overrides.get("current_period_end", None)
    event.data.cancel_at_period_end = data_overrides.get("cancel_at_period_end", False)
    return event


def _polar_subscription(
    subscription_id="sub_member",
    product_id="prod_sapling",
    created_at=datetime(2026, 10, 1, tzinfo=timezone.utc),
    current_period_end=None,
    cancel_at_period_end=False,
):
    subscription = Mock()
    subscription.id = subscription_id
    subscription.product_id = product_id
    subscription.created_at = created_at
    subscription.current_period_end = current_period_end
    subscription.cancel_at_period_end = cancel_at_period_end
    return subscription


def _mock_polar(MockPolar, live_subscriptions):
    """Make Polar report these live membership subscriptions for the user."""
    mock_polar = MockPolar.return_value.__enter__.return_value
    mock_polar.subscriptions.list.return_value.result.items = live_subscriptions
    return mock_polar


def _post_webhook(api_client, event, live_subscriptions):
    with (
        patch("mwmbl.platform.api.validate_event", return_value=event),
        patch("mwmbl.platform.api.Polar") as MockPolar,
    ):
        mock_polar = _mock_polar(MockPolar, live_subscriptions)
        response = api_client.post("/api/v1/platform/billing/webhook", content_type="application/json", data={})
    return response, mock_polar


# ---------------------------------------------------------------------------
# Tiers and current membership
# ---------------------------------------------------------------------------


@pytest.mark.django_db
def test_list_tiers_is_public_and_ordered(api_client):
    response = api_client.get("/api/v1/platform/membership/tiers")

    assert response.status_code == 200
    tiers = response.json()
    assert [(t["tier"], t["monthly_price_pence"]) for t in tiers] == [
        ("sprout", 100),
        ("sapling", 500),
        ("canopy", 2_000),
    ]
    assert tiers[1]["name"] == "Sapling"


@pytest.mark.django_db
def test_tier_perks_contain_the_phrases_the_front_end_bolds(api_client):
    response = api_client.get("/api/v1/platform/membership/tiers")

    perks_by_tier = {t["tier"]: " ".join(t["perks"]) for t in response.json()}
    assert "300 Seed Search queries" in perks_by_tier["sprout"]
    assert "1,500 Seed Search queries" in perks_by_tier["sapling"]
    assert "1 million pages" in perks_by_tier["canopy"]


@pytest.mark.django_db
def test_get_membership_not_a_member_returns_404(api_client, user):
    response = api_client.get("/api/v1/platform/membership", **auth_headers(user))

    assert response.status_code == 404


@pytest.mark.django_db
def test_get_membership_returns_tier(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.CANOPY, polar_subscription_id="sub_1")

    response = api_client.get("/api/v1/platform/membership", **auth_headers(user))

    assert response.status_code == 200
    assert response.json()["tier"] == "canopy"
    assert response.json()["cancel_at_period_end"] is False


@pytest.mark.django_db
def test_get_membership_unauthenticated(api_client):
    response = api_client.get("/api/v1/platform/membership")

    assert response.status_code == 401


# ---------------------------------------------------------------------------
# Checkout
# ---------------------------------------------------------------------------


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_checkout_uses_tier_product(api_client, user):
    with patch("mwmbl.platform.api.Polar") as MockPolar:
        mock_polar = _mock_polar(MockPolar, [])
        mock_polar.checkouts.create.return_value.url = "https://polar.example/checkout/member"

        response = api_client.post(
            "/api/v1/platform/membership/checkout",
            content_type="application/json",
            data={"tier": "sapling", "success_url": "https://mwmbl.org/welcome"},
            **auth_headers(user),
        )

    assert response.status_code == 200
    assert response.json()["checkout_url"] == "https://polar.example/checkout/member"
    checkout_params = mock_polar.checkouts.create.call_args[1]["request"]
    assert checkout_params["products"] == ["prod_sapling"]
    assert checkout_params["metadata"] == {"user_id": str(user.id)}
    assert checkout_params["success_url"] == "https://mwmbl.org/welcome"


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_checkout_rejects_existing_member(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SPROUT, polar_subscription_id="sub_1")

    response = api_client.post(
        "/api/v1/platform/membership/checkout",
        content_type="application/json",
        data={"tier": "canopy"},
        **auth_headers(user),
    )

    assert response.status_code == 409


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_checkout_rejects_subscription_paid_before_its_webhook(api_client, user):
    with patch("mwmbl.platform.api.Polar") as MockPolar:
        mock_polar = _mock_polar(MockPolar, [_polar_subscription(product_id="prod_sprout")])

        response = api_client.post(
            "/api/v1/platform/membership/checkout",
            content_type="application/json",
            data={"tier": "canopy"},
            **auth_headers(user),
        )

    assert response.status_code == 409
    list_params = mock_polar.subscriptions.list.call_args[1]
    assert list_params["external_customer_id"] == str(user.id)
    assert sorted(list_params["product_id"]) == ["prod_canopy", "prod_sapling", "prod_sprout"]
    mock_polar.checkouts.create.assert_not_called()


@pytest.mark.django_db
@override_settings(POLAR_PRODUCT_ID_SAPLING="")
def test_checkout_not_configured_returns_503(api_client, user):
    response = api_client.post(
        "/api/v1/platform/membership/checkout",
        content_type="application/json",
        data={"tier": "sapling"},
        **auth_headers(user),
    )

    assert response.status_code == 503


@pytest.mark.django_db
def test_checkout_unknown_tier_is_rejected(api_client, user):
    response = api_client.post(
        "/api/v1/platform/membership/checkout",
        content_type="application/json",
        data={"tier": "oak"},
        **auth_headers(user),
    )

    assert response.status_code == 422


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_checkout_requires_verified_email(api_client, user):
    EmailAddress.objects.filter(user=user).update(verified=False)

    response = api_client.post(
        "/api/v1/platform/membership/checkout",
        content_type="application/json",
        data={"tier": "sprout"},
        **auth_headers(user),
    )

    assert response.status_code == 403


# ---------------------------------------------------------------------------
# Cancel and uncancel
# ---------------------------------------------------------------------------


def _post_membership_action(api_client, user, action, polar_update_result=None, polar_update_error=None):
    with patch("mwmbl.platform.api.Polar") as MockPolar:
        mock_polar = MockPolar.return_value.__enter__.return_value
        mock_polar.subscriptions.update.return_value = polar_update_result
        mock_polar.subscriptions.update.side_effect = polar_update_error
        response = api_client.post(f"/api/v1/platform/membership/{action}", **auth_headers(user))
    return response, mock_polar


def _already_canceled_error():
    raw_response = Mock(status_code=403, text="Subscription is already canceled")
    return AlreadyCanceledSubscription(data=Mock(detail="Subscription is already canceled"), raw_response=raw_response)


@pytest.mark.django_db
def test_cancel_membership_schedules_cancellation(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member")
    period_end = datetime(2026, 11, 1, tzinfo=timezone.utc)

    response, mock_polar = _post_membership_action(
        api_client, user, "cancel", polar_update_result=_polar_subscription(current_period_end=period_end)
    )

    assert response.status_code == 200
    assert response.json()["cancel_at_period_end"] is True
    assert response.json()["tier"] == "sapling"
    update_params = mock_polar.subscriptions.update.call_args[1]
    assert update_params["id"] == "sub_member"
    assert update_params["subscription_update"].cancel_at_period_end is True
    member = Membership.objects.get(user=user)
    assert member.cancel_at_period_end is True
    assert member.current_period_end == period_end


@pytest.mark.django_db
def test_cancel_membership_not_a_member_returns_404(api_client, user):
    response, mock_polar = _post_membership_action(api_client, user, "cancel")

    assert response.status_code == 404
    mock_polar.subscriptions.update.assert_not_called()


@pytest.mark.django_db
def test_cancel_membership_already_cancelling_returns_409(api_client, user):
    Membership.objects.create(
        user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member", cancel_at_period_end=True
    )

    response, mock_polar = _post_membership_action(api_client, user, "cancel")

    assert response.status_code == 409
    mock_polar.subscriptions.update.assert_not_called()


@pytest.mark.django_db
def test_cancel_membership_already_canceled_in_polar_returns_409(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member")

    response, _ = _post_membership_action(api_client, user, "cancel", polar_update_error=_already_canceled_error())

    assert response.status_code == 409
    assert Membership.objects.get(user=user).cancel_at_period_end is False


@pytest.mark.django_db
def test_cancel_membership_requires_verified_email(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member")
    EmailAddress.objects.filter(user=user).update(verified=False)

    response, _ = _post_membership_action(api_client, user, "cancel")

    assert response.status_code == 403


@pytest.mark.django_db
def test_cancel_membership_unauthenticated(api_client):
    response = api_client.post("/api/v1/platform/membership/cancel")

    assert response.status_code == 401


@pytest.mark.django_db
def test_uncancel_membership_removes_scheduled_cancellation(api_client, user):
    Membership.objects.create(
        user=user, tier=MembershipTier.CANOPY, polar_subscription_id="sub_member", cancel_at_period_end=True
    )
    period_end = datetime(2026, 11, 1, tzinfo=timezone.utc)

    response, mock_polar = _post_membership_action(
        api_client, user, "uncancel", polar_update_result=_polar_subscription(current_period_end=period_end)
    )

    assert response.status_code == 200
    assert response.json()["cancel_at_period_end"] is False
    update_params = mock_polar.subscriptions.update.call_args[1]
    assert update_params["id"] == "sub_member"
    assert update_params["subscription_update"].cancel_at_period_end is False
    member = Membership.objects.get(user=user)
    assert member.cancel_at_period_end is False
    assert member.current_period_end == period_end


@pytest.mark.django_db
def test_uncancel_membership_not_a_member_returns_404(api_client, user):
    response, _ = _post_membership_action(api_client, user, "uncancel")

    assert response.status_code == 404


@pytest.mark.django_db
def test_uncancel_membership_not_cancelling_returns_409(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.CANOPY, polar_subscription_id="sub_member")

    response, mock_polar = _post_membership_action(api_client, user, "uncancel")

    assert response.status_code == 409
    mock_polar.subscriptions.update.assert_not_called()


@pytest.mark.django_db
def test_uncancel_membership_already_ended_in_polar_returns_409(api_client, user):
    Membership.objects.create(
        user=user, tier=MembershipTier.CANOPY, polar_subscription_id="sub_member", cancel_at_period_end=True
    )

    response, _ = _post_membership_action(api_client, user, "uncancel", polar_update_error=_already_canceled_error())

    assert response.status_code == 409
    assert Membership.objects.get(user=user).cancel_at_period_end is True


@pytest.mark.django_db
def test_uncancel_membership_does_not_recreate_a_membership_deleted_during_the_polar_call(api_client, user):
    Membership.objects.create(
        user=user, tier=MembershipTier.CANOPY, polar_subscription_id="sub_member", cancel_at_period_end=True
    )

    def revoke_webhook_arrives(**kwargs):
        Membership.objects.filter(user=user).delete()
        return _polar_subscription()

    response, _ = _post_membership_action(api_client, user, "uncancel", polar_update_error=revoke_webhook_arrives)

    assert response.status_code == 404
    assert not Membership.objects.filter(user=user).exists()


@pytest.mark.django_db
def test_cancel_membership_does_not_overwrite_a_subscription_changed_during_the_polar_call(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member")

    def upgrade_webhook_arrives(**kwargs):
        Membership.objects.filter(user=user).update(tier=MembershipTier.CANOPY, polar_subscription_id="sub_new")
        return _polar_subscription()

    response, _ = _post_membership_action(api_client, user, "cancel", polar_update_error=upgrade_webhook_arrives)

    assert response.status_code == 200
    assert response.json()["tier"] == "canopy"
    member = Membership.objects.get(user=user)
    assert member.polar_subscription_id == "sub_new"
    assert member.cancel_at_period_end is False


# ---------------------------------------------------------------------------
# Change tier
# ---------------------------------------------------------------------------


def _post_change(api_client, user, tier, polar_update_result=None, polar_update_error=None):
    with patch("mwmbl.platform.api.Polar") as MockPolar:
        mock_polar = MockPolar.return_value.__enter__.return_value
        mock_polar.subscriptions.update.return_value = polar_update_result
        mock_polar.subscriptions.update.side_effect = polar_update_error
        response = api_client.post(
            "/api/v1/platform/membership/change",
            data={"tier": tier},
            content_type="application/json",
            **auth_headers(user),
        )
    return response, mock_polar


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_change_membership_switches_product_with_proration(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member")
    period_end = datetime(2026, 11, 1, tzinfo=timezone.utc)

    response, mock_polar = _post_change(
        api_client,
        user,
        "canopy",
        polar_update_result=_polar_subscription(product_id="prod_canopy", current_period_end=period_end),
    )

    assert response.status_code == 200
    assert response.json()["tier"] == "canopy"
    update_params = mock_polar.subscriptions.update.call_args[1]
    assert update_params["id"] == "sub_member"
    assert update_params["subscription_update"].product_id == "prod_canopy"
    assert update_params["subscription_update"].proration_behavior == "prorate"
    member = Membership.objects.get(user=user)
    assert member.tier == MembershipTier.CANOPY
    assert member.current_period_end == period_end


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_change_membership_not_a_member_returns_404(api_client, user):
    response, mock_polar = _post_change(api_client, user, "canopy")

    assert response.status_code == 404
    mock_polar.subscriptions.update.assert_not_called()


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_change_membership_to_current_tier_returns_409(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member")

    response, mock_polar = _post_change(api_client, user, "sapling")

    assert response.status_code == 409
    mock_polar.subscriptions.update.assert_not_called()


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_change_membership_while_cancelling_returns_409(api_client, user):
    Membership.objects.create(
        user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member", cancel_at_period_end=True
    )

    response, mock_polar = _post_change(api_client, user, "sprout")

    assert response.status_code == 409
    mock_polar.subscriptions.update.assert_not_called()


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_change_membership_already_canceled_in_polar_returns_409(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member")

    response, _ = _post_change(api_client, user, "canopy", polar_update_error=_already_canceled_error())

    assert response.status_code == 409
    assert Membership.objects.get(user=user).tier == MembershipTier.SAPLING


@pytest.mark.django_db
@override_settings(POLAR_PRODUCT_ID_CANOPY="")
def test_change_membership_not_configured_returns_503(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member")

    response, mock_polar = _post_change(api_client, user, "canopy")

    assert response.status_code == 503
    mock_polar.subscriptions.update.assert_not_called()


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_change_membership_requires_verified_email(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member")
    EmailAddress.objects.filter(user=user).update(verified=False)

    response, _ = _post_change(api_client, user, "canopy")

    assert response.status_code == 403


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_change_membership_leaves_cancel_flag_alone(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member")

    response, _ = _post_change(
        api_client, user, "sprout", polar_update_result=_polar_subscription(product_id="prod_sprout")
    )

    assert response.status_code == 200
    assert response.json()["cancel_at_period_end"] is False
    assert Membership.objects.get(user=user).cancel_at_period_end is False


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_change_membership_locked_in_polar_returns_409(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member")
    raw_response = Mock(status_code=409, text="Subscription is locked")
    locked_error = SubscriptionLocked(data=Mock(detail="Subscription is locked"), raw_response=raw_response)

    response, _ = _post_change(api_client, user, "canopy", polar_update_error=locked_error)

    assert response.status_code == 409
    assert Membership.objects.get(user=user).tier == MembershipTier.SAPLING


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_change_membership_unknown_tier_is_rejected(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member")

    response, mock_polar = _post_change(api_client, user, "redwood")

    assert response.status_code == 422
    mock_polar.subscriptions.update.assert_not_called()


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_change_membership_does_not_recreate_a_membership_deleted_during_the_polar_call(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member")

    def revoke_webhook_arrives(**kwargs):
        Membership.objects.filter(user=user).delete()
        return _polar_subscription(product_id="prod_canopy")

    response, _ = _post_change(api_client, user, "canopy", polar_update_error=revoke_webhook_arrives)

    assert response.status_code == 404
    assert not Membership.objects.filter(user=user).exists()


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_change_membership_does_not_overwrite_a_subscription_changed_during_the_polar_call(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member")

    def new_subscription_webhook_arrives(**kwargs):
        Membership.objects.filter(user=user).update(tier=MembershipTier.SPROUT, polar_subscription_id="sub_new")
        return _polar_subscription(product_id="prod_canopy")

    response, _ = _post_change(api_client, user, "canopy", polar_update_error=new_subscription_webhook_arrives)

    assert response.status_code == 200
    assert response.json()["tier"] == "sprout"
    member = Membership.objects.get(user=user)
    assert member.polar_subscription_id == "sub_new"
    assert member.tier == MembershipTier.SPROUT


@pytest.mark.django_db
def test_change_membership_unauthenticated(api_client):
    response = api_client.post(
        "/api/v1/platform/membership/change", data={"tier": "canopy"}, content_type="application/json"
    )

    assert response.status_code == 401


# ---------------------------------------------------------------------------
# Webhook
# ---------------------------------------------------------------------------


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_webhook_active_creates_membership(api_client, user):
    period_end = datetime(2026, 11, 1, tzinfo=timezone.utc)
    event = _membership_event("subscription.active", user.id)

    response, _ = _post_webhook(api_client, event, [_polar_subscription(current_period_end=period_end)])

    assert response.status_code == 200
    member = Membership.objects.get(user=user)
    assert member.tier == MembershipTier.SAPLING
    assert member.polar_subscription_id == "sub_member"
    assert member.current_period_end == period_end


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_webhook_does_not_touch_usage_billing(api_client, user):
    UserBilling.objects.create(user=user, polar_subscription_id="sub_usage", max_monthly_spend_cents=1_000)

    _post_webhook(api_client, _membership_event("subscription.active", user.id), [_polar_subscription()])
    _post_webhook(api_client, _membership_event("subscription.revoked", user.id, status="canceled"), [])

    billing = UserBilling.objects.get(user=user)
    assert billing.polar_subscription_id == "sub_usage"
    assert billing.max_monthly_spend_cents == 1_000


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_webhook_updated_changes_tier(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SPROUT, polar_subscription_id="sub_member")
    event = _membership_event("subscription.updated", user.id, product_id="prod_canopy")

    _post_webhook(api_client, event, [_polar_subscription(product_id="prod_canopy")])

    assert Membership.objects.get(user=user).tier == MembershipTier.CANOPY


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_webhook_scheduled_cancel_keeps_membership(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member")
    event = _membership_event("subscription.canceled", user.id, cancel_at_period_end=True)

    _post_webhook(api_client, event, [_polar_subscription(cancel_at_period_end=True)])

    assert Membership.objects.get(user=user).cancel_at_period_end is True


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_webhook_revoked_ends_membership(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member")

    _post_webhook(api_client, _membership_event("subscription.revoked", user.id, status="canceled"), [])

    assert not Membership.objects.filter(user=user).exists()


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_webhook_late_event_for_old_subscription_keeps_newer_membership(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.CANOPY, polar_subscription_id="sub_new")
    event = _membership_event("subscription.revoked", user.id, status="canceled", subscription_id="sub_old")

    _post_webhook(api_client, event, [_polar_subscription(subscription_id="sub_new", product_id="prod_canopy")])

    assert Membership.objects.get(user=user).polar_subscription_id == "sub_new"


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_webhook_retried_live_event_does_not_revive_ended_membership(api_client, user):
    event = _membership_event("subscription.updated", user.id, status="active")

    _post_webhook(api_client, event, [])

    assert not Membership.objects.filter(user=user).exists()


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_webhook_live_event_for_old_subscription_does_not_replace_newer(api_client, user):
    Membership.objects.create(user=user, tier=MembershipTier.CANOPY, polar_subscription_id="sub_new")
    event = _membership_event("subscription.updated", user.id, product_id="prod_sprout", subscription_id="sub_old")

    _post_webhook(api_client, event, [_polar_subscription(subscription_id="sub_new", product_id="prod_canopy")])

    member = Membership.objects.get(user=user)
    assert member.polar_subscription_id == "sub_new"
    assert member.tier == MembershipTier.CANOPY


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_webhook_duplicate_subscriptions_keep_newest_and_cancel_the_rest(api_client, user):
    older = _polar_subscription(
        subscription_id="sub_sprout", product_id="prod_sprout", created_at=datetime(2026, 10, 1, tzinfo=timezone.utc)
    )
    newer = _polar_subscription(
        subscription_id="sub_canopy", product_id="prod_canopy", created_at=datetime(2026, 10, 2, tzinfo=timezone.utc)
    )
    event = _membership_event("subscription.active", user.id, product_id="prod_sprout", subscription_id="sub_sprout")

    _, mock_polar = _post_webhook(api_client, event, [older, newer])

    member = Membership.objects.get(user=user)
    assert member.polar_subscription_id == "sub_canopy"
    assert member.tier == MembershipTier.CANOPY
    update_params = mock_polar.subscriptions.update.call_args[1]
    assert update_params["id"] == "sub_sprout"
    assert update_params["subscription_update"].cancel_at_period_end is True


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_webhook_duplicate_already_cancelling_is_left_alone(api_client, user):
    older = _polar_subscription(subscription_id="sub_sprout", cancel_at_period_end=True)
    newer = _polar_subscription(subscription_id="sub_canopy", created_at=datetime(2026, 10, 2, tzinfo=timezone.utc))

    _, mock_polar = _post_webhook(api_client, _membership_event("subscription.updated", user.id), [older, newer])

    mock_polar.subscriptions.update.assert_not_called()


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_webhook_past_due_keeps_membership_and_join_date(api_client, user):
    member = Membership.objects.create(user=user, tier=MembershipTier.SAPLING, polar_subscription_id="sub_member")
    event = _membership_event("subscription.past_due", user.id, status="past_due")

    _, mock_polar = _post_webhook(api_client, event, [_polar_subscription()])

    assert Membership.objects.get(user=user).started == member.started
    assert "past_due" in mock_polar.subscriptions.list.call_args[1]["status"]


@pytest.mark.django_db
@PRODUCT_SETTINGS
def test_webhook_retired_product_is_not_treated_as_usage_billing(api_client, user):
    UserBilling.objects.create(user=user, polar_subscription_id="sub_usage", max_monthly_spend_cents=1_000)
    Membership.objects.create(user=user, tier=MembershipTier.SPROUT, polar_subscription_id="sub_member")
    event = _membership_event("subscription.revoked", user.id, product_id="prod_retired", status="canceled")

    _post_webhook(api_client, event, [])

    billing = UserBilling.objects.get(user=user)
    assert billing.polar_subscription_id == "sub_usage"
    assert billing.max_monthly_spend_cents == 1_000
    assert not Membership.objects.filter(user=user).exists()