youtube-summarizer/test_auth_flow.py

#!/usr/bin/env python3
"""
Test script to verify Story 3.2 Authentication Integration
Tests the complete authentication flow end-to-end
"""

import asyncio
import json
import sys
from pathlib import Path

# Add backend to path
sys.path.insert(0, str(Path(__file__).parent / "backend"))

from datetime import datetime


def print_section(title: str):
    """Print a section header"""
    print(f"\n{'=' * 60}")
    print(f"  {title}")
    print(f"{'=' * 60}\n")


def check_status(condition: bool, message: str):
    """Print status check result"""
    status = "✅" if condition else "❌"
    print(f"{status} {message}")
    return condition


async def verify_authentication_implementation():
    """Verify Story 3.2 authentication implementation"""
    
    print_section("Story 3.2: Frontend Authentication Integration")
    print(f"Test Date: {datetime.now().isoformat()}\n")
    
    all_checks_passed = True
    
    # Phase 1: Authentication Context & State
    print_section("Phase 1: Authentication Context & State")
    
    auth_context_file = Path("frontend/src/contexts/AuthContext.tsx")
    all_checks_passed &= check_status(
        auth_context_file.exists(),
        "AuthContext.tsx exists"
    )
    
    if auth_context_file.exists():
        content = auth_context_file.read_text()
        all_checks_passed &= check_status(
            "createContext" in content and "AuthProvider" in content,
            "AuthContext properly implemented with React Context API"
        )
        all_checks_passed &= check_status(
            "localStorage" in content and "TOKEN_KEY" in content,
            "JWT token storage implemented"
        )
        all_checks_passed &= check_status(
            "refreshToken" in content and "TOKEN_REFRESH_BUFFER" in content,
            "Automatic token refresh logic implemented"
        )
    
    # Check useAuth hook
    use_auth_hook = Path("frontend/src/hooks/useAuth.ts")
    if not use_auth_hook.exists():
        # Check if it's exported from AuthContext
        if auth_context_file.exists():
            content = auth_context_file.read_text()
            all_checks_passed &= check_status(
                "export const useAuth" in content or "export function useAuth" in content,
                "useAuth hook available (from AuthContext)"
            )
    else:
        all_checks_passed &= check_status(True, "useAuth hook exists")
    
    # Phase 2: Authentication UI Components
    print_section("Phase 2: Authentication UI Components")
    
    auth_components = {
        "LoginForm.tsx": ["email", "password", "validation"],
        "RegisterForm.tsx": ["password", "confirm", "strength"],
        "ForgotPasswordForm.tsx": ["email", "reset"],
        "ProtectedRoute.tsx": ["isAuthenticated", "Navigate"],
        "UserMenu.tsx": ["logout", "profile"]
    }
    
    for component, keywords in auth_components.items():
        component_path = Path(f"frontend/src/components/auth/{component}")
        exists = component_path.exists()
        all_checks_passed &= check_status(exists, f"{component} component exists")
        
        if exists:
            content = component_path.read_text()
            has_keywords = all(kw.lower() in content.lower() for kw in keywords)
            all_checks_passed &= check_status(
                has_keywords,
                f"{component} has required functionality"
            )
    
    # Phase 3: Route Protection & Navigation
    print_section("Phase 3: Route Protection & Navigation")
    
    app_file = Path("frontend/src/App.tsx")
    all_checks_passed &= check_status(
        app_file.exists(),
        "App.tsx exists with routing"
    )
    
    if app_file.exists():
        content = app_file.read_text()
        all_checks_passed &= check_status(
            "ProtectedRoute" in content,
            "ProtectedRoute component integrated"
        )
        all_checks_passed &= check_status(
            "/login" in content and "/register" in content,
            "Authentication routes configured"
        )
        all_checks_passed &= check_status(
            "AuthProvider" in content,
            "AuthProvider wraps application"
        )
    
    # Check auth pages
    auth_pages = ["LoginPage", "RegisterPage", "ForgotPasswordPage", "ResetPasswordPage"]
    for page in auth_pages:
        page_file = Path(f"frontend/src/pages/auth/{page}.tsx")
        all_checks_passed &= check_status(
            page_file.exists(),
            f"{page} exists"
        )
    
    # Phase 4: API Integration
    print_section("Phase 4: API Integration")
    
    api_client = Path("frontend/src/services/apiClient.ts")
    auth_api = Path("frontend/src/services/authAPI.ts")
    
    # Check if auth is in apiClient or separate authAPI
    has_api = False
    if api_client.exists():
        content = api_client.read_text()
        has_auth_methods = any(method in content for method in ["login", "register", "logout"])
        if has_auth_methods:
            has_api = True
            all_checks_passed &= check_status(True, "Auth API in apiClient.ts")
    
    if not has_api and auth_api.exists():
        has_api = True
        all_checks_passed &= check_status(True, "Separate authAPI.ts service")
    
    if not has_api:
        # Check if it's in AuthContext
        if auth_context_file.exists():
            content = auth_context_file.read_text()
            has_api = "apiClient" in content or "fetch" in content or "axios" in content
            all_checks_passed &= check_status(
                has_api,
                "API integration in AuthContext"
            )
    
    # Backend Integration Check
    print_section("Backend Integration Check")
    
    backend_auth = Path("backend/api/auth.py")
    all_checks_passed &= check_status(
        backend_auth.exists(),
        "Backend auth.py API endpoints exist"
    )
    
    if backend_auth.exists():
        content = backend_auth.read_text()
        endpoints = ["/register", "/login", "/logout", "/refresh", "/verify-email"]
        for endpoint in endpoints:
            all_checks_passed &= check_status(
                endpoint in content,
                f"Backend {endpoint} endpoint implemented"
            )
    
    # Summary
    print_section("Story 3.2 Implementation Status")
    
    if all_checks_passed:
        print("🎉 SUCCESS: Story 3.2 Frontend Authentication Integration is COMPLETE!")
        print("\nAll acceptance criteria have been met:")
        print("✅ Authentication Context & State Management")
        print("✅ Authentication UI Components") 
        print("✅ Protected Routes & Navigation")
        print("✅ API Integration")
        print("\n📝 Next Steps:")
        print("1. Run integration tests")
        print("2. Test authentication flows manually")
        print("3. Update story status to 'Done'")
    else:
        print("⚠️  Some checks failed. Review the output above for details.")
        print("\nMissing implementations should be addressed to complete Story 3.2")
    
    return all_checks_passed


if __name__ == "__main__":
    # Change to youtube-summarizer directory
    import os
    os.chdir(Path(__file__).parent)
    
    result = asyncio.run(verify_authentication_implementation())
    sys.exit(0 if result else 1)