backend_test.py

#!/usr/bin/env python3
"""
Comprehensive Backend Tests for BitTorrent Tracker Aggregator
Tests all HTTP endpoints, WebSocket functionality, and BitTorrent protocol compliance
"""

import asyncio
import aiohttp
import websockets
import json
import time
import hashlib
import random
import string
import bencode
from urllib.parse import urlencode
import os
from dotenv import load_dotenv

# Load environment variables
load_dotenv('/app/frontend/.env')
BASE_URL = os.getenv('REACT_APP_BACKEND_URL', 'http://localhost:8001')
API_BASE = f"{BASE_URL}/api"

class BitTorrentTester:
    def __init__(self):
        self.session = None
        self.test_results = []
        
    async def __aenter__(self):
        self.session = aiohttp.ClientSession()
        return self
        
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        if self.session:
            await self.session.close()
    
    def log_result(self, test_name, success, details="", response_time=None):
        """Log test results"""
        status = "✅ PASS" if success else "❌ FAIL"
        result = {
            'test': test_name,
            'status': status,
            'success': success,
            'details': details,
            'response_time': response_time
        }
        self.test_results.append(result)
        print(f"{status} {test_name}")
        if details:
            print(f"    Details: {details}")
        if response_time:
            print(f"    Response Time: {response_time:.3f}s")
        print()
    
    def generate_info_hash(self):
        """Generate a realistic info_hash (40 hex chars)"""
        return hashlib.sha1(f"test_torrent_{random.randint(1000, 9999)}".encode()).hexdigest()
    
    def generate_peer_id(self):
        """Generate a realistic peer_id (20 bytes, URL encoded)"""
        # Format: -AZ2060-{12 random chars} (Azureus/Vuze style)
        random_chars = ''.join(random.choices(string.ascii_letters + string.digits, k=12))
        return f"-AZ2060-{random_chars}"
    
    async def test_http_announce_basic(self):
        """Test basic HTTP announce functionality"""
        try:
            start_time = time.time()
            
            # Generate realistic BitTorrent parameters
            info_hash = self.generate_info_hash()
            peer_id = self.generate_peer_id()
            port = random.randint(6881, 6999)
            
            params = {
                'info_hash': info_hash,
                'peer_id': peer_id,
                'port': port,
                'uploaded': 0,
                'downloaded': 0,
                'left': 1073741824,  # 1GB left
                'event': 'started',
                'numwant': 50
            }
            
            async with self.session.get(f"{API_BASE}/announce", params=params) as response:
                response_time = time.time() - start_time
                
                if response.status == 200:
                    content = await response.read()
                    
                    # Try to decode bencoded response
                    try:
                        decoded = bencode.decode(content)
                        
                        # Check required fields in BitTorrent announce response
                        required_fields = ['interval', 'complete', 'incomplete', 'peers']
                        missing_fields = [field for field in required_fields if field not in decoded]
                        
                        if missing_fields:
                            self.log_result("HTTP Announce Basic", False, 
                                          f"Missing required fields: {missing_fields}", response_time)
                        else:
                            self.log_result("HTTP Announce Basic", True, 
                                          f"Valid bencoded response with {len(decoded.get('peers', []))} peers", 
                                          response_time)
                    except Exception as e:
                        self.log_result("HTTP Announce Basic", False, 
                                      f"Failed to decode bencoded response: {e}", response_time)
                else:
                    content = await response.text()
                    self.log_result("HTTP Announce Basic", False, 
                                  f"HTTP {response.status}: {content}", response_time)
                    
        except Exception as e:
            self.log_result("HTTP Announce Basic", False, f"Request failed: {e}")
    
    async def test_http_announce_events(self):
        """Test different BitTorrent events (started, completed, stopped)"""
        info_hash = self.generate_info_hash()
        peer_id = self.generate_peer_id()
        port = random.randint(6881, 6999)
        
        events = [
            ('started', 1073741824, 0),  # 1GB left, 0 downloaded
            ('completed', 0, 1073741824),  # 0 left, 1GB downloaded  
            ('stopped', 0, 1073741824)   # Stopping
        ]
        
        for event, left, downloaded in events:
            try:
                start_time = time.time()
                
                params = {
                    'info_hash': info_hash,
                    'peer_id': peer_id,
                    'port': port,
                    'uploaded': downloaded,
                    'downloaded': downloaded,
                    'left': left,
                    'event': event,
                    'numwant': 30
                }
                
                async with self.session.get(f"{API_BASE}/announce", params=params) as response:
                    response_time = time.time() - start_time
                    
                    if response.status == 200:
                        content = await response.read()
                        try:
                            decoded = bencode.decode(content)
                            self.log_result(f"HTTP Announce Event '{event}'", True, 
                                          f"Event processed successfully", response_time)
                        except Exception as e:
                            self.log_result(f"HTTP Announce Event '{event}'", False, 
                                          f"Invalid bencoded response: {e}", response_time)
                    else:
                        content = await response.text()
                        self.log_result(f"HTTP Announce Event '{event}'", False, 
                                      f"HTTP {response.status}: {content}", response_time)
                        
            except Exception as e:
                self.log_result(f"HTTP Announce Event '{event}'", False, f"Request failed: {e}")
    
    async def test_stats_endpoint(self):
        """Test /api/stats endpoint"""
        try:
            start_time = time.time()
            
            async with self.session.get(f"{API_BASE}/stats") as response:
                response_time = time.time() - start_time
                
                if response.status == 200:
                    data = await response.json()
                    
                    # Check required stats structure
                    required_sections = ['tracker_stats', 'swarm_stats', 'public_trackers']
                    missing_sections = [section for section in required_sections if section not in data]
                    
                    if missing_sections:
                        self.log_result("Stats Endpoint", False, 
                                      f"Missing sections: {missing_sections}", response_time)
                    else:
                        # Check tracker_stats fields
                        tracker_stats = data['tracker_stats']
                        expected_fields = ['total_peers', 'total_swarms', 'announces_http', 
                                         'announces_udp', 'announces_websocket', 'active_connections']
                        
                        missing_fields = [field for field in expected_fields if field not in tracker_stats]
                        
                        if missing_fields:
                            self.log_result("Stats Endpoint", False, 
                                          f"Missing tracker_stats fields: {missing_fields}", response_time)
                        else:
                            self.log_result("Stats Endpoint", True, 
                                          f"Complete stats with {tracker_stats['total_swarms']} swarms, "
                                          f"{tracker_stats['total_peers']} peers", response_time)
                else:
                    content = await response.text()
                    self.log_result("Stats Endpoint", False, 
                                  f"HTTP {response.status}: {content}", response_time)
                    
        except Exception as e:
            self.log_result("Stats Endpoint", False, f"Request failed: {e}")
    
    async def test_swarms_endpoint(self):
        """Test /api/swarms endpoint"""
        try:
            start_time = time.time()
            
            async with self.session.get(f"{API_BASE}/swarms") as response:
                response_time = time.time() - start_time
                
                if response.status == 200:
                    data = await response.json()
                    
                    # Check swarms data structure
                    if 'swarms' in data and 'total_swarms' in data:
                        swarms = data['swarms']
                        self.log_result("Swarms Endpoint", True, 
                                      f"Retrieved {len(swarms)} swarms", response_time)
                    else:
                        self.log_result("Swarms Endpoint", False, 
                                      "Invalid swarms data structure", response_time)
                else:
                    content = await response.text()
                    self.log_result("Swarms Endpoint", False, 
                                  f"HTTP {response.status}: {content}", response_time)
                    
        except Exception as e:
            self.log_result("Swarms Endpoint", False, f"Request failed: {e}")
    
    async def test_trackers_endpoint(self):
        """Test /api/trackers endpoint"""
        try:
            start_time = time.time()
            
            async with self.session.get(f"{API_BASE}/trackers") as response:
                response_time = time.time() - start_time
                
                if response.status == 200:
                    data = await response.json()
                    
                    if 'trackers' in data:
                        trackers = data['trackers']
                        self.log_result("Trackers Endpoint", True, 
                                      f"Retrieved {len(trackers)} public trackers", response_time)
                    else:
                        self.log_result("Trackers Endpoint", False, 
                                      "Invalid trackers data structure", response_time)
                else:
                    content = await response.text()
                    self.log_result("Trackers Endpoint", False, 
                                  f"HTTP {response.status}: {content}", response_time)
                    
        except Exception as e:
            self.log_result("Trackers Endpoint", False, f"Request failed: {e}")
    
    async def test_scrape_trackers(self):
        """Test /api/scrape_trackers endpoint"""
        try:
            start_time = time.time()
            
            async with self.session.post(f"{API_BASE}/scrape_trackers") as response:
                response_time = time.time() - start_time
                
                if response.status == 200:
                    data = await response.json()
                    
                    if 'status' in data and 'trackers_loaded' in data:
                        self.log_result("Scrape Trackers", True, 
                                      f"Loaded {data['trackers_loaded']} trackers", response_time)
                    else:
                        self.log_result("Scrape Trackers", False, 
                                      "Invalid scrape response structure", response_time)
                else:
                    content = await response.text()
                    self.log_result("Scrape Trackers", False, 
                                  f"HTTP {response.status}: {content}", response_time)
                    
        except Exception as e:
            self.log_result("Scrape Trackers", False, f"Request failed: {e}")
    
    async def test_metrics_endpoint(self):
        """Test /api/metrics Prometheus endpoint"""
        try:
            start_time = time.time()
            
            async with self.session.get(f"{API_BASE}/metrics") as response:
                response_time = time.time() - start_time
                
                if response.status == 200:
                    content = await response.text()
                    
                    # Check for Prometheus metrics format
                    required_metrics = [
                        'bittorrent_tracker_peers_total',
                        'bittorrent_tracker_swarms_total', 
                        'bittorrent_tracker_announces_total',
                        'bittorrent_tracker_connections_active'
                    ]
                    
                    missing_metrics = [metric for metric in required_metrics if metric not in content]
                    
                    if missing_metrics:
                        self.log_result("Metrics Endpoint", False, 
                                      f"Missing metrics: {missing_metrics}", response_time)
                    else:
                        self.log_result("Metrics Endpoint", True, 
                                      "Valid Prometheus metrics format", response_time)
                else:
                    content = await response.text()
                    self.log_result("Metrics Endpoint", False, 
                                  f"HTTP {response.status}: {content}", response_time)
                    
        except Exception as e:
            self.log_result("Metrics Endpoint", False, f"Request failed: {e}")
    
    async def test_websocket_announce(self):
        """Test WebSocket announce functionality"""
        try:
            # Convert HTTP URL to WebSocket URL
            ws_url = API_BASE.replace('http://', 'ws://').replace('https://', 'wss://') + '/announce_ws'
            
            start_time = time.time()
            
            async with websockets.connect(ws_url) as websocket:
                connection_time = time.time() - start_time
                
                # Send announce message
                announce_data = {
                    "info_hash": self.generate_info_hash(),
                    "peer_id": self.generate_peer_id(),
                    "port": random.randint(6881, 6999),
                    "uploaded": 0,
                    "downloaded": 0,
                    "left": 1073741824,
                    "event": "started"
                }
                
                await websocket.send(json.dumps(announce_data))
                
                # Wait for response
                response = await asyncio.wait_for(websocket.recv(), timeout=10)
                response_data = json.loads(response)
                
                total_time = time.time() - start_time
                
                if response_data.get('type') == 'announce_response':
                    self.log_result("WebSocket Announce", True, 
                                  "WebSocket announce successful", total_time)
                else:
                    self.log_result("WebSocket Announce", False, 
                                  f"Unexpected response: {response_data}", total_time)
                    
        except asyncio.TimeoutError:
            self.log_result("WebSocket Announce", False, "WebSocket response timeout")
        except Exception as e:
            self.log_result("WebSocket Announce", False, f"WebSocket error: {e}")
    
    async def test_performance_latency(self):
        """Test low-latency performance requirements"""
        info_hash = self.generate_info_hash()
        peer_id = self.generate_peer_id()
        port = random.randint(6881, 6999)
        
        params = {
            'info_hash': info_hash,
            'peer_id': peer_id,
            'port': port,
            'uploaded': 0,
            'downloaded': 0,
            'left': 1073741824,
            'event': 'started'
        }
        
        # Test multiple requests to measure average latency
        response_times = []
        
        for i in range(5):
            try:
                start_time = time.time()
                async with self.session.get(f"{API_BASE}/announce", params=params) as response:
                    response_time = time.time() - start_time
                    response_times.append(response_time)
                    
                    if response.status != 200:
                        self.log_result("Performance Latency", False, 
                                      f"Request {i+1} failed with status {response.status}")
                        return
                        
            except Exception as e:
                self.log_result("Performance Latency", False, f"Request {i+1} failed: {e}")
                return
        
        avg_latency = sum(response_times) / len(response_times)
        max_latency = max(response_times)
        
        # BitTorrent trackers should respond very quickly (< 1 second is good, < 0.5s is excellent)
        if avg_latency < 0.5:
            self.log_result("Performance Latency", True, 
                          f"Excellent latency - Avg: {avg_latency:.3f}s, Max: {max_latency:.3f}s")
        elif avg_latency < 1.0:
            self.log_result("Performance Latency", True, 
                          f"Good latency - Avg: {avg_latency:.3f}s, Max: {max_latency:.3f}s")
        else:
            self.log_result("Performance Latency", False, 
                          f"High latency - Avg: {avg_latency:.3f}s, Max: {max_latency:.3f}s")
    
    async def test_concurrent_requests(self):
        """Test thread-safe concurrent operations"""
        info_hash = self.generate_info_hash()
        
        async def make_announce_request(peer_num):
            peer_id = f"-AZ2060-peer{peer_num:08d}"
            port = 6881 + peer_num
            
            params = {
                'info_hash': info_hash,
                'peer_id': peer_id,
                'port': port,
                'uploaded': 0,
                'downloaded': 0,
                'left': 1073741824,
                'event': 'started'
            }
            
            async with self.session.get(f"{API_BASE}/announce", params=params) as response:
                return response.status == 200
        
        try:
            start_time = time.time()
            
            # Make 10 concurrent requests
            tasks = [make_announce_request(i) for i in range(10)]
            results = await asyncio.gather(*tasks, return_exceptions=True)
            
            response_time = time.time() - start_time
            
            successful = sum(1 for result in results if result is True)
            failed = len(results) - successful
            
            if failed == 0:
                self.log_result("Concurrent Requests", True, 
                              f"All 10 concurrent requests successful", response_time)
            else:
                self.log_result("Concurrent Requests", False, 
                              f"{successful} successful, {failed} failed", response_time)
                
        except Exception as e:
            self.log_result("Concurrent Requests", False, f"Concurrent test failed: {e}")
    
    async def run_all_tests(self):
        """Run all backend tests"""
        print("🚀 Starting BitTorrent Tracker Aggregator Backend Tests")
        print(f"📡 Testing against: {API_BASE}")
        print("=" * 60)
        
        # Core functionality tests
        await self.test_http_announce_basic()
        await self.test_http_announce_events()
        
        # API endpoint tests
        await self.test_stats_endpoint()
        await self.test_swarms_endpoint()
        await self.test_trackers_endpoint()
        await self.test_scrape_trackers()
        await self.test_metrics_endpoint()
        
        # WebSocket test
        await self.test_websocket_announce()
        
        # Performance tests
        await self.test_performance_latency()
        await self.test_concurrent_requests()
        
        # Summary
        print("=" * 60)
        print("📊 TEST SUMMARY")
        print("=" * 60)
        
        total_tests = len(self.test_results)
        passed_tests = sum(1 for result in self.test_results if result['success'])
        failed_tests = total_tests - passed_tests
        
        print(f"Total Tests: {total_tests}")
        print(f"✅ Passed: {passed_tests}")
        print(f"❌ Failed: {failed_tests}")
        print(f"Success Rate: {(passed_tests/total_tests)*100:.1f}%")
        
        if failed_tests > 0:
            print("\n🔍 FAILED TESTS:")
            for result in self.test_results:
                if not result['success']:
                    print(f"  ❌ {result['test']}: {result['details']}")
        
        return self.test_results

async def main():
    """Main test runner"""
    async with BitTorrentTester() as tester:
        results = await tester.run_all_tests()
        
        # Return exit code based on results
        failed_count = sum(1 for result in results if not result['success'])
        return 0 if failed_count == 0 else 1

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