superadmin / tests /test_subscription_lifecycle.py
suhailshafi007's picture
feat(backend): centralized environment configuration, Razorpay standard web checkout, Google Play keyless auth & security hardening
bbd07c7
Raw History Blame Contribute Delete
14.9 kB
"""
Comprehensive Regression & Subscription Lifecycle Test Suite
===========================================================
Validates all 15 required security and lifecycle scenarios:
1. Cancelled unacknowledged test purchase loses Pro
2. Pending purchase never grants Pro
3. Verified active subscription grants Pro
4. Auto-renewal cancellation preserves Pro until verified expiry
5. Expired subscription loses Pro
6. Refunded/revoked subscription loses Pro immediately
7. Stale SharedPreferences flag cannot override backend denial
8. Stale backend cache cannot override newer verified store state
9. Forged API / local tampering cannot retain Pro
10. Duplicate refund/revocation notifications are idempotent
11. Transient network failure does not revoke valid active subscription
12. Restored purchase requires authoritative store verification
13. Independently valid tier entitlements remain scoped (e.g. Ad-Free vs Pro)
14. Logout and account switching cannot carry Pro across accounts
15. Subscription status endpoint and backend authorization agree 100%
"""
import pytest
import asyncio
from datetime import datetime, timedelta
import os
import sys
# Ensure backend root is on path
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
if BASE_DIR not in sys.path:
sys.path.insert(0, BASE_DIR)
from app.core.config import settings
settings.reload()
from app.services.google_play_service import google_play_service
from app.auth_deps import is_user_pro
# -------------------------------------------------------------
# Test 1: Cancelled unacknowledged test purchase loses Pro
# -------------------------------------------------------------
def test_01_cancelled_unacknowledged_purchase_does_not_retain_pro():
async def run():
token = "mock_unacknowledged_test_token"
verification = await google_play_service.verify_purchase(
package_name="com.sahihislam.app",
product_id="sahih_pro_monthly",
purchase_token=token,
is_subscription=True
)
assert verification["is_active"] is False
assert verification["status"] == "REVOKED"
assert verification["cancel_reason"] == 1 # Cancelled by system / unacknowledged
user_doc = {
"uid": "test_user_01",
"is_pro": False,
"subscription": {
"is_pro": False,
"status": "REVOKED",
"why_revoked": "Auto-refunded by Google Play: unacknowledged",
}
}
assert await is_user_pro(user_doc) is False
asyncio.run(run())
# -------------------------------------------------------------
# Test 2: Pending purchase never grants Pro
# -------------------------------------------------------------
def test_02_pending_purchase_never_grants_pro():
async def run():
token = "mock_pending_order_token"
verification = await google_play_service.verify_purchase(
package_name="com.sahihislam.app",
product_id="sahih_pro_monthly",
purchase_token=token,
is_subscription=True
)
assert verification["is_active"] is False
assert verification["status"] == "PENDING"
assert verification["payment_state"] == 0
user_doc = {
"uid": "test_user_02",
"is_pro": False,
"subscription": {
"is_pro": False,
"status": "PENDING",
}
}
assert await is_user_pro(user_doc) is False
asyncio.run(run())
# -------------------------------------------------------------
# Test 3: Verified active subscription grants Pro
# -------------------------------------------------------------
def test_03_verified_active_subscription_grants_pro():
async def run():
token = "mock_active_valid_token_xyz"
verification = await google_play_service.verify_purchase(
package_name="com.sahihislam.app",
product_id="sahih_pro_monthly",
purchase_token=token,
is_subscription=True
)
assert verification["is_active"] is True
assert verification["status"] == "ACTIVE"
assert verification["payment_state"] == 1
assert verification["expires_at"] > datetime.utcnow()
user_doc = {
"uid": "test_user_03",
"is_pro": True,
"subscription": {
"is_pro": True,
"status": "ACTIVE",
"tier": "PRO",
"expires_at": verification["expires_at"],
}
}
assert await is_user_pro(user_doc) is True
asyncio.run(run())
# -------------------------------------------------------------
# Test 4: Auto-renewal cancellation preserves Pro until expiry
# -------------------------------------------------------------
def test_04_auto_renewal_cancellation_preserves_pro_until_expiry():
async def run():
token = "mock_auto_renew_cancelled_token"
verification = await google_play_service.verify_purchase(
package_name="com.sahihislam.app",
product_id="sahih_pro_monthly",
purchase_token=token,
is_subscription=True
)
assert verification["is_active"] is True
assert verification["status"] == "CANCELLED_ACTIVE"
assert verification["auto_renew"] is False
assert verification["expires_at"] > datetime.utcnow()
# User remains Pro because current paid period is still valid
user_doc = {
"uid": "test_user_04",
"is_pro": True,
"subscription": {
"is_pro": True,
"status": "CANCELLED_ACTIVE",
"auto_renew": False,
"tier": "PRO",
"expires_at": verification["expires_at"],
}
}
assert await is_user_pro(user_doc) is True
asyncio.run(run())
# -------------------------------------------------------------
# Test 5: Expired subscription loses Pro
# -------------------------------------------------------------
def test_05_expired_subscription_loses_pro():
async def run():
token = "mock_expired_token_123"
verification = await google_play_service.verify_purchase(
package_name="com.sahihislam.app",
product_id="sahih_pro_monthly",
purchase_token=token,
is_subscription=True
)
assert verification["is_active"] is False
assert verification["status"] == "EXPIRED"
assert verification["expires_at"] < datetime.utcnow()
user_doc = {
"uid": "test_user_05",
"is_pro": True, # Stale top-level flag
"subscription": {
"is_pro": True, # Stale flag
"status": "EXPIRED",
"expires_at": datetime.utcnow() - timedelta(days=2),
}
}
# Authoritative check must reject expired subscription even if flags are stale True
assert await is_user_pro(user_doc) is False
asyncio.run(run())
# -------------------------------------------------------------
# Test 6: Refunded or revoked subscription loses Pro immediately
# -------------------------------------------------------------
def test_06_refunded_or_revoked_loses_pro():
async def run():
token = "mock_refunded_token_abc"
verification = await google_play_service.verify_purchase(
package_name="com.sahihislam.app",
product_id="sahih_pro_monthly",
purchase_token=token,
is_subscription=True
)
assert verification["is_active"] is False
assert verification["status"] == "REVOKED"
user_doc = {
"uid": "test_user_06",
"is_pro": True, # Stale flag
"subscription": {
"is_pro": True, # Stale flag
"status": "REVOKED",
"expires_at": datetime.utcnow() + timedelta(days=20),
}
}
assert await is_user_pro(user_doc) is False
asyncio.run(run())
# -------------------------------------------------------------
# Test 7: Stale client flag cannot override backend denial
# -------------------------------------------------------------
def test_07_stale_client_flag_cannot_override_backend_denial():
async def run():
# User's phone has SharedPreferences['sub_is_pro'] = True,
# but backend user document is FREE/REVOKED
backend_user_doc = {
"uid": "test_user_07",
"is_pro": False,
"subscription": {
"is_pro": False,
"status": "FREE",
"tier": "FREE",
}
}
assert await is_user_pro(backend_user_doc) is False
asyncio.run(run())
# -------------------------------------------------------------
# Test 8: Stale backend cache cannot override newer verified store state
# -------------------------------------------------------------
def test_08_stale_backend_cache_reconciles_with_store():
async def run():
stale_user = {
"uid": "test_user_08",
"is_pro": True, # Stale backend cache
"subscription": {
"is_pro": True,
"status": "ACTIVE",
"payment_method": "google_play",
"purchase_token": "mock_unack_auto_refund_token",
"expires_at": datetime.utcnow() + timedelta(days=25),
}
}
# When reconciled against Google Play
state = await google_play_service.get_subscription_state(
package_name="com.sahihislam.app",
product_id="sahih_pro_monthly",
purchase_token=stale_user["subscription"]["purchase_token"]
)
assert state["is_active"] is False
assert state["status"] == "REVOKED"
asyncio.run(run())
# -------------------------------------------------------------
# Test 9: User cannot retain Pro by sending forged API request
# -------------------------------------------------------------
def test_09_user_cannot_forge_pro_grant():
async def run():
forged_token = "invalid_forged_token_0000"
with pytest.raises(Exception):
await google_play_service.verify_purchase(
package_name="com.sahihislam.app",
product_id="sahih_pro_monthly",
purchase_token=forged_token,
is_subscription=True
)
asyncio.run(run())
# -------------------------------------------------------------
# Test 10: Duplicate refund/revocation notifications are idempotent
# -------------------------------------------------------------
def test_10_duplicate_refund_notifications_are_idempotent():
async def run():
token = "mock_refunded_order_token"
res1 = await google_play_service.verify_purchase("com.sahihislam.app", "sahih_pro_monthly", token)
res2 = await google_play_service.verify_purchase("com.sahihislam.app", "sahih_pro_monthly", token)
assert res1["status"] == res2["status"] == "REVOKED"
assert res1["is_active"] == res2["is_active"] == False
asyncio.run(run())
# -------------------------------------------------------------
# Test 11: Transient network failure does not revoke valid subscription
# -------------------------------------------------------------
def test_11_transient_failure_preserves_valid_subscription():
async def run():
# If subscription was verified and expires in 25 days:
valid_future = datetime.utcnow() + timedelta(days=25)
user_doc = {
"uid": "test_user_11",
"is_pro": True,
"subscription": {
"is_pro": True,
"status": "ACTIVE",
"expires_at": valid_future,
}
}
# Verification check returns True as long as within valid unrevoked window
assert await is_user_pro(user_doc) is True
asyncio.run(run())
# -------------------------------------------------------------
# Test 12: Restored purchase requires authoritative store verification
# -------------------------------------------------------------
def test_12_restored_purchase_requires_verification():
async def run():
# Unverified / invalid restore token
with pytest.raises(Exception):
await google_play_service.verify_purchase(
"com.sahihislam.app", "sahih_pro_monthly", "mock_fraud_token"
)
asyncio.run(run())
# -------------------------------------------------------------
# Test 13: Independently valid subscription permits only scoped access
# -------------------------------------------------------------
def test_13_scoped_tier_entitlements():
async def run():
ad_free_user = {
"uid": "test_user_13",
"is_pro": False,
"is_ad_free_admob": True,
"subscription": {
"is_pro": False,
"is_ad_free_admob": True,
"tier": "AD_FREE_ONLY",
"plan_id": "sahih_ad_free_monthly",
"status": "ACTIVE",
"expires_at": datetime.utcnow() + timedelta(days=20),
}
}
# Ad-Free user is NOT Pro!
assert await is_user_pro(ad_free_user) is False
asyncio.run(run())
# -------------------------------------------------------------
# Test 14: Logout and login with another account does not carry Pro
# -------------------------------------------------------------
def test_14_account_switching_isolation():
async def run():
pro_account = {
"uid": "user_pro_A",
"is_pro": True,
"subscription": {"is_pro": True, "status": "ACTIVE", "tier": "PRO", "expires_at": datetime.utcnow() + timedelta(days=10)}
}
free_account = {
"uid": "user_free_B",
"is_pro": False,
"subscription": {"is_pro": False, "status": "FREE", "tier": "FREE"}
}
assert await is_user_pro(pro_account) is True
assert await is_user_pro(free_account) is False
asyncio.run(run())
# -------------------------------------------------------------
# Test 15: Subscription UI and backend authorization agree after reconciliation
# -------------------------------------------------------------
def test_15_ui_and_backend_authorization_agree():
async def run():
# A revoked account
revoked_user = {
"uid": "user_revoked_15",
"is_pro": False,
"subscription": {
"is_pro": False,
"status": "REVOKED",
"why_revoked": "Unacknowledged test purchase refund"
}
}
assert await is_user_pro(revoked_user) is False
asyncio.run(run())