admin_szolgáltatók_
This commit is contained in:
Roo
186
tests/active/test_use_unverified_provider.py
Normal file
186
tests/active/test_use_unverified_provider.py
Normal file
@@ -0,0 +1,186 @@
|
||||
"""
|
||||
Test: USE_UNVERIFIED_PROVIDER pontszabály bekötése (Card #362)
|
||||
=============================================================
|
||||
Ellenőrzi, hogy a find_or_create_provider_by_name() függvény helyesen
|
||||
differenciál a PROVIDER_CONFIRMATION és USE_UNVERIFIED_PROVIDER között.
|
||||
|
||||
Logika:
|
||||
1. Ha a provider APPROVED -> PROVIDER_VERIFIED_USE (100 XP)
|
||||
2. Ha a provider PENDING és a használó user a provider létrehozója -> PROVIDER_CONFIRMATION (150 XP)
|
||||
3. Ha a provider PENDING és a használó user NEM a provider létrehozója -> USE_UNVERIFIED_PROVIDER (200 XP)
|
||||
|
||||
Használat:
|
||||
docker compose exec sf_api python3 /app/backend/tests/active/test_use_unverified_provider.py
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent / "backend"))
|
||||
|
||||
from sqlalchemy import select, delete
|
||||
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, async_sessionmaker
|
||||
from app.core.config import settings
|
||||
from app.models.identity.social import ServiceProvider, ModerationStatus, SourceType
|
||||
from app.models.gamification.gamification import PointRule, UserStats, PointsLedger
|
||||
from app.services.provider_service import find_or_create_provider_by_name, _award_provider_points
|
||||
|
||||
logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
|
||||
logger = logging.getLogger("Test-USE_UNVERIFIED_PROVIDER")
|
||||
|
||||
TEST_USER_ID = 1 # Provider creator (superadmin@profibot.hu)
|
||||
TEST_OTHER_USER_ID = 2 # Other user using the provider (admin@profibot.hu)
|
||||
TEST_PROVIDER_NAME = "Test Unverified Provider Card362"
|
||||
|
||||
|
||||
async def cleanup_test_data(db: AsyncSession):
|
||||
"""Clean up any leftover test data."""
|
||||
await db.execute(
|
||||
delete(PointsLedger).where(
|
||||
PointsLedger.user_id.in_([TEST_USER_ID, TEST_OTHER_USER_ID])
|
||||
)
|
||||
)
|
||||
await db.execute(
|
||||
delete(UserStats).where(
|
||||
UserStats.user_id.in_([TEST_USER_ID, TEST_OTHER_USER_ID])
|
||||
)
|
||||
)
|
||||
await db.execute(
|
||||
delete(ServiceProvider).where(ServiceProvider.name == TEST_PROVIDER_NAME)
|
||||
)
|
||||
await db.commit()
|
||||
|
||||
|
||||
async def test_use_unverified_provider():
|
||||
"""
|
||||
Test scenario:
|
||||
1. User A (TEST_USER_ID) creates a provider via find_or_create_provider_by_name()
|
||||
-> Should return PROVIDER_DISCOVERY (300 XP) - new provider
|
||||
2. User A uses the same provider again
|
||||
-> Should return PROVIDER_CONFIRMATION (150 XP) - same user, pending provider
|
||||
3. User B (TEST_OTHER_USER_ID) uses the same provider
|
||||
-> Should return USE_UNVERIFIED_PROVIDER (200 XP) - different user, pending provider
|
||||
"""
|
||||
engine = create_async_engine(settings.DATABASE_URL, echo=False)
|
||||
async_session = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
|
||||
|
||||
async with async_session() as db:
|
||||
try:
|
||||
# Clean up first
|
||||
await cleanup_test_data(db)
|
||||
|
||||
# =========================================================
|
||||
# STEP 1: User A creates a new provider (PROVIDER_DISCOVERY)
|
||||
# =========================================================
|
||||
logger.info("=" * 60)
|
||||
logger.info("STEP 1: User A creates a new provider")
|
||||
logger.info("=" * 60)
|
||||
|
||||
provider, action_key = await find_or_create_provider_by_name(
|
||||
db=db,
|
||||
name=TEST_PROVIDER_NAME,
|
||||
added_by_user_id=TEST_USER_ID,
|
||||
)
|
||||
|
||||
assert provider is not None, "Provider should be created"
|
||||
assert action_key == "PROVIDER_DISCOVERY", (
|
||||
f"Expected PROVIDER_DISCOVERY, got {action_key}"
|
||||
)
|
||||
assert provider.status == ModerationStatus.pending, (
|
||||
f"Expected pending status, got {provider.status}"
|
||||
)
|
||||
assert provider.added_by_user_id == TEST_USER_ID, (
|
||||
f"Expected added_by_user_id={TEST_USER_ID}, got {provider.added_by_user_id}"
|
||||
)
|
||||
logger.info(f"✅ STEP 1 PASS: action_key={action_key}, provider_id={provider.id}")
|
||||
|
||||
# Check that points were awarded
|
||||
stats_stmt = select(UserStats).where(UserStats.user_id == TEST_USER_ID)
|
||||
stats = (await db.execute(stats_stmt)).scalar_one_or_none()
|
||||
assert stats is not None, "UserStats should exist"
|
||||
assert stats.total_xp >= 300, (
|
||||
f"Expected at least 300 XP, got {stats.total_xp}"
|
||||
)
|
||||
logger.info(f"✅ STEP 1 XP CHECK: total_xp={stats.total_xp}")
|
||||
|
||||
# =========================================================
|
||||
# STEP 2: User A uses the same provider again (PROVIDER_CONFIRMATION)
|
||||
# =========================================================
|
||||
logger.info("=" * 60)
|
||||
logger.info("STEP 2: User A uses the same provider again")
|
||||
logger.info("=" * 60)
|
||||
|
||||
# Re-fetch to get clean state
|
||||
await db.refresh(provider)
|
||||
|
||||
provider2, action_key2 = await find_or_create_provider_by_name(
|
||||
db=db,
|
||||
name=TEST_PROVIDER_NAME,
|
||||
added_by_user_id=TEST_USER_ID,
|
||||
)
|
||||
|
||||
assert provider2.id == provider.id, "Should be the same provider"
|
||||
assert action_key2 == "PROVIDER_CONFIRMATION", (
|
||||
f"Expected PROVIDER_CONFIRMATION, got {action_key2}"
|
||||
)
|
||||
logger.info(f"✅ STEP 2 PASS: action_key={action_key2}")
|
||||
|
||||
# =========================================================
|
||||
# STEP 3: User B uses the same provider (USE_UNVERIFIED_PROVIDER)
|
||||
# =========================================================
|
||||
logger.info("=" * 60)
|
||||
logger.info("STEP 3: User B uses the same provider")
|
||||
logger.info("=" * 60)
|
||||
|
||||
provider3, action_key3 = await find_or_create_provider_by_name(
|
||||
db=db,
|
||||
name=TEST_PROVIDER_NAME,
|
||||
added_by_user_id=TEST_OTHER_USER_ID,
|
||||
)
|
||||
|
||||
assert provider3.id == provider.id, "Should be the same provider"
|
||||
assert action_key3 == "USE_UNVERIFIED_PROVIDER", (
|
||||
f"Expected USE_UNVERIFIED_PROVIDER, got {action_key3}"
|
||||
)
|
||||
logger.info(f"✅ STEP 3 PASS: action_key={action_key3}")
|
||||
|
||||
# Check that User B got points
|
||||
stats_stmt2 = select(UserStats).where(UserStats.user_id == TEST_OTHER_USER_ID)
|
||||
stats2 = (await db.execute(stats_stmt2)).scalar_one_or_none()
|
||||
assert stats2 is not None, "UserStats should exist for User B"
|
||||
assert stats2.total_xp >= 200, (
|
||||
f"Expected at least 200 XP for User B, got {stats2.total_xp}"
|
||||
)
|
||||
logger.info(f"✅ STEP 3 XP CHECK: User B total_xp={stats2.total_xp}")
|
||||
|
||||
# =========================================================
|
||||
# SUMMARY
|
||||
# =========================================================
|
||||
logger.info("=" * 60)
|
||||
logger.info("🎉 ALL TESTS PASSED!")
|
||||
logger.info(f" - PROVIDER_DISCOVERY (300 XP): ✅ User A created provider")
|
||||
logger.info(f" - PROVIDER_CONFIRMATION (150 XP): ✅ User A reused own provider")
|
||||
logger.info(f" - USE_UNVERIFIED_PROVIDER (200 XP): ✅ User B used pending provider")
|
||||
logger.info("=" * 60)
|
||||
|
||||
# Clean up
|
||||
await cleanup_test_data(db)
|
||||
|
||||
except AssertionError as e:
|
||||
logger.error(f"❌ TEST FAILED: {e}")
|
||||
await db.rollback()
|
||||
await cleanup_test_data(db)
|
||||
sys.exit(1)
|
||||
except Exception as e:
|
||||
logger.error(f"❌ UNEXPECTED ERROR: {e}", exc_info=True)
|
||||
await db.rollback()
|
||||
await cleanup_test_data(db)
|
||||
sys.exit(1)
|
||||
finally:
|
||||
await engine.dispose()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(test_use_unverified_provider())
|
||||
Reference in New Issue
Block a user