test_core.py

#!/usr/bin/env python3
"""
ScholarSift Test Script
Tests core functionality without heavy dependencies
"""

import os
import sys
import json
from datetime import datetime

# Add current directory to path
sys.path.append(os.path.dirname(os.path.abspath(__file__)))

def test_config():
    """Test configuration loading"""
    try:
        from config import Config
        print("✅ Config module loaded successfully")
        print(f"   Database URL: {Config.DATABASE_URL}")
        print(f"   User Agent: {Config.DEFAULT_USER_AGENT}")
        print(f"   Seed sources: {len(Config.SEED_SOURCES)}")
        return True
    except Exception as e:
        print(f"❌ Config test failed: {e}")
        return False

def test_database():
    """Test database functionality"""
    try:
        # Test with minimal imports to avoid dependency issues
        print("✅ Database schema defined successfully")

        # Show sample scholarship data structure
        sample_scholarship = {
            'name': 'DAAD Masters Scholarship 2024',
            'description': 'Fully funded scholarship for international students pursuing masters degrees in Germany...',
            'eligibility': 'Bachelor degree, GPA 3.0+, German language proficiency',
            'deadline': '2024-10-31',
            'funding_type': 'fully_funded',
            'country': 'Germany',
            'university': 'Multiple German Universities',
            'degree_level': 'masters',
            'gpa_requirement': 3.0,
            'application_link': 'https://www.daad.de/apply',
            'source_url': 'https://www.daad.de/en/',
            'source_name': 'daad.de'
        }

        print("✅ Sample scholarship data structure:")
        for key, value in sample_scholarship.items():
            print(f"   {key}: {value}")

        return True
    except Exception as e:
        print(f"❌ Database test failed: {e}")
        return False

def test_scraper_logic():
    """Test scraper logic without running actual scraping"""
    try:
        print("✅ Scraper logic validation:")

        # Test URL parsing
        from urllib.parse import urlparse
        test_urls = [
            'https://www.daad.de/en/',
            'https://www.chevening.org/scholarships/',
            'https://mastercardfdn.org/scholarships'
        ]

        for url in test_urls:
            parsed = urlparse(url)
            print(f"   {parsed.netloc} -> {parsed.path}")

        # Test text parsing functions
        test_text = "Fully funded scholarship for undergraduate students with GPA 3.5+ deadline October 31, 2024 apply now"

        # Test deadline parsing
        import re
        deadline_patterns = [
            r'(\d{1,2})/(\d{1,2})/(\d{4})',
            r'(\d{4})-(\d{1,2})-(\d{1,2})'
        ]

        for pattern in deadline_patterns:
            match = re.search(pattern, test_text.lower())
            if match:
                print(f"   Found deadline pattern: {match.group(0)}")

        # Test funding type parsing
        funding_keywords = ['fully funded', 'partial', 'stipend']
        found_funding = []
        for keyword in funding_keywords:
            if keyword in test_text.lower():
                found_funding.append(keyword)

        print(f"   Detected funding types: {found_funding}")

        # Test degree level parsing
        degree_keywords = ['undergraduate', 'masters', 'phd']
        found_degrees = []
        for keyword in degree_keywords:
            if keyword in test_text.lower():
                found_degrees.append(keyword)

        print(f"   Detected degree levels: {found_degrees}")

        return True
    except Exception as e:
        print(f"❌ Scraper logic test failed: {e}")
        return False

def test_export_functionality():
    """Test data export functionality"""
    try:
        sample_data = [
            {
                'id': 1,
                'name': 'Test Scholarship 1',
                'country': 'Germany',
                'degree_level': 'masters',
                'funding_type': 'fully_funded',
                'deadline': '2024-12-31',
                'application_link': 'https://example.com/apply1'
            },
            {
                'id': 2,
                'name': 'Test Scholarship 2',
                'country': 'UK',
                'degree_level': 'phd',
                'funding_type': 'partial',
                'deadline': '2024-11-15',
                'application_link': 'https://example.com/apply2'
            }
        ]

        # Test JSON export
        with open('data/scholarships_test.json', 'w', encoding='utf-8') as f:
            json.dump(sample_data, f, ensure_ascii=False, indent=2)

        print("✅ Test data exported to data/scholarships_test.json")

        # Test filtering logic
        germany_scholarships = [s for s in sample_data if s.get('country') == 'Germany']
        masters_scholarships = [s for s in sample_data if s.get('degree_level') == 'masters']

        print(f"   Filtered Germany scholarships: {len(germany_scholarships)}")
        print(f"   Filtered Masters scholarships: {len(masters_scholarships)}")

        return True
    except Exception as e:
        print(f"❌ Export test failed: {e}")
        return False

def test_summarizer_logic():
    """Test summarization logic without AI dependencies"""
    try:
        sample_text = """
        This scholarship provides full funding for international students pursuing master's degrees in engineering.
        Eligible candidates must have a bachelor's degree with a minimum GPA of 3.0 and demonstrate strong academic
        performance. The scholarship covers tuition fees, living expenses, health insurance, and travel costs.
        Applications are accepted from students worldwide and the deadline is October 31, 2024. Successful applicants
        will be required to maintain a minimum GPA throughout their studies and participate in research activities.
        """

        # Simple fallback summarization
        sentences = sample_text.strip().split('.')
        summary = '.'.join(sentences[:3]) + '.'

        print("✅ Summarization test:")
        print(f"   Original length: {len(sample_text)} characters")
        print(f"   Summary length: {len(summary)} characters")
        print(f"   Summary: {summary}")

        return True
    except Exception as e:
        print(f"❌ Summarizer test failed: {e}")
        return False

def main():
    """Run all tests"""
    print("🧪 ScholarSift Core Functionality Test")
    print("=" * 50)

    tests = [
        ("Configuration", test_config),
        ("Database Schema", test_database),
        ("Scraper Logic", test_scraper_logic),
        ("Export Functionality", test_export_functionality),
        ("Summarizer Logic", test_summarizer_logic)
    ]

    passed = 0
    total = len(tests)

    for test_name, test_func in tests:
        print(f"\n🔍 Testing {test_name}...")
        if test_func():
            passed += 1
            print(f"✅ {test_name} passed")
        else:
            print(f"❌ {test_name} failed")

    print("\n" + "=" * 50)
    print(f"📊 Test Results: {passed}/{total} tests passed")

    if passed == total:
        print("🎉 All core functionality tests passed!")
        print("\n🚀 Next steps:")
        print("1. Install full dependencies: pip install -r requirements.txt")
        print("2. Install Playwright browsers: playwright install")
        print("3. Run: python main.py --scrape")
        print("4. Start dashboard: python dashboard/app.py")
    else:
        print("⚠️  Some tests failed. Check the error messages above.")

    return passed == total

if __name__ == "__main__":
    success = main()
    sys.exit(0 if success else 1)