kincses/service-finder
1
0
Fork 0
Code Issues 52 Pull Requests Packages Projects 2 Releases Wiki Activity

refaktor címtár

Browse Source
This commit is contained in:
Roo
2026-07-01 19:49:58 +00:00
parent 6e627d0ebe
commit 7654913d21
198 changed files with 3485 additions and 1609 deletions
Download Patch File Download Diff File Expand all files Collapse all files

98
tests/active/test_use_unverified_provider.py
View File

@@ -1,13 +1,20 @@
"""
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.
Test: find_or_create_provider_by_name() refactored signature (P0 Architecture Cleanup)
=======================================================================================
Ellenőrzi, hogy a find_or_create_provider_by_name() függvény az új
(provider, created) tuple-t adja vissza a gamification logika nélkül.
P0 ARCHITECTURE CLEANUP (2026-07-01):
======================================
- A gamification/XP logika ELTÁVOLÍTVA a service rétegből.
- A visszatérési érték immár (provider, created) tuple.
- created=True: új provider lett létrehozva
- created=False: meglévő provider lett lekérve
- A pg_trgm similarity threshold 0.3 -> 0.6 (hamis pozitívok csökkentése)
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)
1. Ha a provider nem létezik -> új provider létrehozva, created=True
2. Ha a provider már létezik -> meglévő visszaadva, created=False
Használat:
docker compose exec sf_api python3 /app/backend/tests/active/test_use_unverified_provider.py
@@ -24,8 +31,7 @@ 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
from app.services.provider_service import find_or_create_provider_by_name
logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
logger = logging.getLogger("Test-USE_UNVERIFIED_PROVIDER")
@@ -37,31 +43,21 @@ 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():
async def test_find_or_create_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
-> Should return (provider, created=True) - new provider
2. User A uses the same provider again
-> Should return PROVIDER_CONFIRMATION (150 XP) - same user, pending provider
-> Should return (provider, created=False) - existing provider
3. User B (TEST_OTHER_USER_ID) uses the same provider
-> Should return USE_UNVERIFIED_PROVIDER (200 XP) - different user, pending provider
-> Should return (provider, created=False) - existing provider
"""
engine = create_async_engine(settings.DATABASE_URL, echo=False)
async_session = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
@@ -72,21 +68,21 @@ async def test_use_unverified_provider():
await cleanup_test_data(db)
# =========================================================
# STEP 1: User A creates a new provider (PROVIDER_DISCOVERY)
# STEP 1: User A creates a new provider (created=True)
# =========================================================
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(
provider, created = 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 created is True, (
f"Expected created=True for new provider, got {created}"
)
assert provider.status == ModerationStatus.pending, (
f"Expected pending status, got {provider.status}"
@@ -94,19 +90,10 @@ async def test_use_unverified_provider():
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}")
logger.info(f"✅ STEP 1 PASS: created={created}, provider_id={provider.id}")
# =========================================================
# STEP 2: User A uses the same provider again (PROVIDER_CONFIRMATION)
# STEP 2: User A uses the same provider again (created=False)
# =========================================================
logger.info("=" * 60)
logger.info("STEP 2: User A uses the same provider again")
@@ -115,54 +102,45 @@ async def test_use_unverified_provider():
# Re-fetch to get clean state
await db.refresh(provider)
provider2, action_key2 = await find_or_create_provider_by_name(
provider2, created2 = 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}"
assert created2 is False, (
f"Expected created=False for existing provider, got {created2}"
)
logger.info(f"✅ STEP 2 PASS: action_key={action_key2}")
logger.info(f"✅ STEP 2 PASS: created={created2}")
# =========================================================
# STEP 3: User B uses the same provider (USE_UNVERIFIED_PROVIDER)
# STEP 3: User B uses the same provider (created=False)
# =========================================================
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(
provider3, created3 = 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}"
assert created3 is False, (
f"Expected created=False for existing provider, got {created3}"
)
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}")
logger.info(f"✅ STEP 3 PASS: created={created3}")
# =========================================================
# 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(f" - New provider created: ✅ created=True")
logger.info(f" - Same user re-fetch: ✅ created=False")
logger.info(f" - Different user re-fetch: ✅ created=False")
logger.info("=" * 60)
# Clean up
@@ -183,4 +161,4 @@ async def test_use_unverified_provider():
if __name__ == "__main__":
asyncio.run(test_use_unverified_provider())
asyncio.run(test_find_or_create_provider())