tests/validate_mongodb_data.py

#!/usr/bin/env python3
"""
Validate MongoDB data collection
"""
import asyncio
import os
from dotenv import load_dotenv
from datetime import datetime

load_dotenv()

async def validate_mongodb_data():
    """Check what data is actually in MongoDB"""
    try:
        from analytics.database import get_sessions_collection, get_messages_collection
        
        print("🔍 Validating MongoDB Data Collection")
        print("=" * 50)
        
        # Get collections
        sessions_collection = await get_sessions_collection()
        messages_collection = await get_messages_collection()
        
        if sessions_collection is None or messages_collection is None:
            print("❌ Database collections not available")
            return
        
        # Check sessions
        print("\n📊 SESSIONS DATA:")
        sessions_count = await sessions_collection.count_documents({})
        print(f"Total sessions: {sessions_count}")
        
        if sessions_count > 0:
            # Get recent sessions
            recent_sessions = await sessions_collection.find({}).sort("start_time", -1).limit(5).to_list(5)
            print("\nRecent sessions:")
            for i, session in enumerate(recent_sessions, 1):
                print(f"  {i}. Session ID: {session.get('session_id', 'N/A')}")
                print(f"     Start: {session.get('start_time', 'N/A')}")
                print(f"     Status: {session.get('status', 'N/A')}")
                print(f"     Messages: {session.get('message_count', 0)}")
                print(f"     Search used: {session.get('search_used', False)}")
                print()
        
        # Check messages
        print("\n💬 MESSAGES DATA:")
        messages_count = await messages_collection.count_documents({})
        print(f"Total messages: {messages_count}")
        
        if messages_count > 0:
            # Get recent messages
            recent_messages = await messages_collection.find({}).sort("timestamp", -1).limit(5).to_list(5)
            print("\nRecent messages:")
            for i, message in enumerate(recent_messages, 1):
                print(f"  {i}. Message ID: {message.get('message_id', 'N/A')}")
                print(f"     Session: {message.get('session_id', 'N/A')}")
                print(f"     Timestamp: {message.get('timestamp', 'N/A')}")
                print(f"     Prompt length: {message.get('prompt_length', 0)}")
                print(f"     Response time: {message.get('response_time_ms', 0)}ms")
                print(f"     Used search: {message.get('used_search', False)}")
                print(f"     Success: {message.get('success', False)}")
                print()
        
        # Check today's data
        today_start = datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0)
        messages_today = await messages_collection.count_documents({
            "timestamp": {"$gte": today_start}
        })
        print(f"\n📅 Messages today: {messages_today}")
        
        # Check active sessions
        active_sessions = await sessions_collection.count_documents({
            "status": "active"
        })
        print(f"🟢 Active sessions: {active_sessions}")
        
        # Check search usage
        messages_with_search = await messages_collection.count_documents({
            "used_search": True
        })
        search_percentage = (messages_with_search / messages_count * 100) if messages_count > 0 else 0
        print(f"🔍 Search usage: {messages_with_search}/{messages_count} ({search_percentage:.1f}%)")
        
        return {
            "sessions_count": sessions_count,
            "messages_count": messages_count,
            "messages_today": messages_today,
            "active_sessions": active_sessions,
            "search_usage_percentage": search_percentage
        }
        
    except Exception as e:
        print(f"❌ Error validating MongoDB data: {e}")
        import traceback
        traceback.print_exc()
        return None

async def test_dashboard_data():
    """Test dashboard data retrieval"""
    try:
        from analytics.dashboard import get_basic_stats
        
        print("\n🎯 DASHBOARD DATA:")
        print("=" * 50)
        
        stats = await get_basic_stats()
        print("Dashboard stats:")
        for key, value in stats.items():
            print(f"  {key}: {value}")
        
        return stats
        
    except Exception as e:
        print(f"❌ Error getting dashboard data: {e}")
        import traceback
        traceback.print_exc()
        return None

async def main():
    print("🚀 MongoDB Data Validation & Dashboard Check")
    print("=" * 60)
    
    # Validate MongoDB data
    mongodb_data = await validate_mongodb_data()
    
    # Test dashboard data
    dashboard_data = await test_dashboard_data()
    
    # Compare results
    if mongodb_data and dashboard_data:
        print("\n🔄 DATA COMPARISON:")
        print("=" * 50)
        print(f"MongoDB sessions: {mongodb_data['sessions_count']} | Dashboard: {dashboard_data.get('total_sessions', 'N/A')}")
        print(f"MongoDB messages: {mongodb_data['messages_count']} | Dashboard: {dashboard_data.get('total_messages', 'N/A')}")
        print(f"MongoDB today: {mongodb_data['messages_today']} | Dashboard: {dashboard_data.get('messages_today', 'N/A')}")
        print(f"MongoDB active: {mongodb_data['active_sessions']} | Dashboard: {dashboard_data.get('active_sessions', 'N/A')}")
        print(f"MongoDB search %: {mongodb_data['search_usage_percentage']:.1f} | Dashboard: {dashboard_data.get('search_usage_percentage', 'N/A')}")
        
        # Check for discrepancies
        discrepancies = []
        if mongodb_data['sessions_count'] != dashboard_data.get('total_sessions', 0):
            discrepancies.append("sessions count")
        if mongodb_data['messages_count'] != dashboard_data.get('total_messages', 0):
            discrepancies.append("messages count")
        if mongodb_data['messages_today'] != dashboard_data.get('messages_today', 0):
            discrepancies.append("today's messages")
        
        if discrepancies:
            print(f"\n⚠️  DISCREPANCIES FOUND: {', '.join(discrepancies)}")
        else:
            print("\n✅ All data matches between MongoDB and Dashboard!")

if __name__ == "__main__":
    asyncio.run(main())