swingmusic-extended/test_core_functionality.py

#!/usr/bin/env python3
"""
Test core Spotify functionality without dependency issues
"""

import json
import logging
import sys
import os

# Add the src directory to the path
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def test_real_data_extraction():
    """Test that we can extract real data properly"""
    logger.info("Testing real data extraction...")
    
    try:
        from swingmusic.services.spotify_web_player_client import get_spotify_web_player_client
        
        client = get_spotify_web_player_client()
        
        # Test with a known working track
        track_id = "4iV5W9uYEdYUVa79Axb7Rh"  # Blinding Lights
        track = client.get_track(track_id)
        
        if track:
            logger.info("✅ Real track data extraction: SUCCESS")
            logger.info(f"Track Name: {track.name}")
            logger.info(f"Track ID: {track.id}")
            logger.info(f"Duration: {track.duration_ms}ms ({track.duration_ms/1000:.1f}s)")
            logger.info(f"Explicit: {track.explicit}")
            
            if track.artists:
                logger.info(f"Artists ({len(track.artists)}):")
                for i, artist in enumerate(track.artists):
                    logger.info(f"  {i+1}. {artist.get('name', 'Unknown')} (ID: {artist.get('id', 'N/A')})")
            else:
                logger.warning("⚠️  No artist data found")
            
            if track.album:
                logger.info(f"Album: {track.album.get('name', 'Unknown')} (ID: {track.album.get('id', 'N/A')})")
            else:
                logger.warning("⚠️  No album data found")
            
            return True
        else:
            logger.error("❌ Failed to get track data")
            return False
            
    except Exception as e:
        logger.error(f"Test failed: {e}")
        import traceback
        traceback.print_exc()
        return False

def test_album_data():
    """Test album data extraction"""
    logger.info("Testing album data extraction...")
    
    try:
        from swingmusic.services.spotify_web_player_client import get_spotify_web_player_client
        
        client = get_spotify_web_player_client()
        
        # Test with a known working album
        album_id = "1DFixLWUoKaZYxZkLUKQu9"  # Divide
        album = client.get_album(album_id)
        
        if album:
            logger.info("✅ Real album data extraction: SUCCESS")
            logger.info(f"Album Name: {album.name}")
            logger.info(f"Album ID: {album.id}")
            logger.info(f"Total Tracks: {album.total_tracks}")
            logger.info(f"Album Type: {album.album_type}")
            logger.info(f"Release Date: {album.release_date}")
            
            if album.artists:
                logger.info(f"Artists ({len(album.artists)}):")
                for i, artist in enumerate(album.artists):
                    logger.info(f"  {i+1}. {artist.get('name', 'Unknown')}")
            
            logger.info(f"Tracks in album: {len(album.tracks)}")
            if album.tracks:
                logger.info("Sample tracks:")
                for i, track in enumerate(album.tracks[:3]):  # Show first 3 tracks
                    logger.info(f"  {i+1}. {track.name} ({track.duration_ms/1000:.1f}s)")
            
            return True
        else:
            logger.error("❌ Failed to get album data")
            return False
            
    except Exception as e:
        logger.error(f"Test failed: {e}")
        import traceback
        traceback.print_exc()
        return False

def test_metadata_client_compatibility():
    """Test that the metadata client works with our new implementation"""
    logger.info("Testing metadata client compatibility...")
    
    try:
        from swingmusic.services.spotify_metadata_client import get_spotify_metadata_client
        
        client = get_spotify_metadata_client()
        
        # Test track lookup through the metadata client
        track = client.get_track("4iV5W9uYEdYUVa79Axb7Rh")
        
        if track:
            logger.info("✅ Metadata client track lookup: SUCCESS")
            logger.info(f"Track: {track.name}")
            logger.info(f"Duration: {track.duration_ms}ms")
            
            # Test album lookup
            album = client.get_album("1DFixLWUoKaZYxZkLUKQu9")
            if album:
                logger.info("✅ Metadata client album lookup: SUCCESS")
                logger.info(f"Album: {album.name}")
                logger.info(f"Tracks: {len(album.tracks)}")
                
                return True
            else:
                logger.error("❌ Metadata client album lookup failed")
                return False
        else:
            logger.error("❌ Metadata client track lookup failed")
            return False
            
    except Exception as e:
        logger.error(f"Test failed: {e}")
        import traceback
        traceback.print_exc()
        return False

def test_cross_platform_matching():
    """Test Song.link cross-platform matching"""
    logger.info("Testing Song.link cross-platform matching...")
    
    try:
        from swingmusic.services.songlink_client import get_songlink_client
        
        client = get_songlink_client()
        
        # Test cross-platform links
        links = client.get_links_from_spotify_id("4iV5W9uYEdYUVa79Axb7Rh")
        
        if links:
            logger.info("✅ Song.link cross-platform links: SUCCESS")
            logger.info(f"Available platforms: {list(links.links.keys())}")
            
            # Test specific platforms
            if links.tidal_url:
                logger.info(f"✅ Tidal: Available")
            else:
                logger.info("⚠️  Tidal: Not available")
            
            if links.qobuz_url:
                logger.info(f"✅ Qobuz: Available")
            else:
                logger.info("⚠️  Qobuz: Not available")
            
            if links.amazon_url:
                logger.info(f"✅ Amazon Music: Available")
            else:
                logger.info("⚠️  Amazon Music: Not available")
            
            # Test availability check
            availability = client.check_availability("4iV5W9uYEdYUVa79Axb7Rh")
            if availability:
                logger.info("✅ Availability check: SUCCESS")
                logger.info(f"Tidal: {availability.tidal}")
                logger.info(f"Qobuz: {availability.qobuz}")
                logger.info(f"Amazon: {availability.amazon}")
                
                return True
            else:
                logger.error("❌ Availability check failed")
                return False
        else:
            logger.error("❌ Song.link links failed")
            return False
            
    except Exception as e:
        logger.error(f"Test failed: {e}")
        import traceback
        traceback.print_exc()
        return False

def main():
    """Run all core functionality tests"""
    print("=" * 70)
    print("Core Spotify Functionality Test")
    print("=" * 70)
    
    tests = [
        ("Real Data Extraction", test_real_data_extraction),
        ("Album Data Extraction", test_album_data),
        ("Metadata Client Compatibility", test_metadata_client_compatibility),
        ("Cross-Platform Matching", test_cross_platform_matching),
    ]
    
    results = {}
    
    for test_name, test_func in tests:
        print(f"\n{test_name}")
        print("-" * 50)
        try:
            results[test_name] = test_func()
        except Exception as e:
            logger.error(f"Test {test_name} failed with exception: {e}")
            results[test_name] = False
    
    # Summary
    print("\n" + "=" * 70)
    print("Core Functionality Test Results")
    print("=" * 70)
    
    for test_name, success in results.items():
        status = "✅ WORKING" if success else "❌ FAILED"
        print(f"{test_name:.<30} {status}")
    
    total_tests = len(results)
    passed_tests = sum(results.values())
    
    print(f"\nOverall: {passed_tests}/{total_tests} core features working")
    
    if passed_tests == total_tests:
        print("🎉 All core functionality working perfectly!")
        print("✅ Real Spotify data retrieval confirmed!")
        print("✅ Works exactly like SpotiFLAC!")
        print("✅ No Spotify account required!")
        print("✅ No Premium subscription needed!")
    elif passed_tests >= 3:
        print("✅ Core functionality working! Minor issues remain.")
    else:
        print("❌ Major functionality issues need to be resolved.")
    
    print("=" * 70)
    
    return passed_tests == total_tests

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