local_swarm/tests/test_federation_metrics.py

"""Tests for federation metrics and peer timeout."""

import sys
import os
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src'))

import pytest
from datetime import datetime
from network.discovery import PeerInfo, PeerMetrics
from network.federation import FederationClient, PeerVote


class TestPeerMetrics:
    """Test peer metrics tracking."""
    
    def test_peer_metrics_defaults(self):
        """Test default metric values."""
        metrics = PeerMetrics()
        assert metrics.total_requests == 0
        assert metrics.successful_requests == 0
        assert metrics.failed_requests == 0
        assert metrics.success_rate == 1.0  # No requests = 100% success
    
    def test_record_success(self):
        """Test recording successful requests."""
        metrics = PeerMetrics()
        metrics.record_success(100.0)
        
        assert metrics.total_requests == 1
        assert metrics.successful_requests == 1
        assert metrics.failed_requests == 0
        assert metrics.success_rate == 1.0
        assert metrics.avg_latency_ms == 100.0
        
        # Record another success
        metrics.record_success(200.0)
        assert metrics.total_requests == 2
        assert metrics.avg_latency_ms == 150.0  # (100 + 200) / 2
    
    def test_record_failure(self):
        """Test recording failed requests."""
        metrics = PeerMetrics()
        metrics.record_failure("Connection timeout")
        
        assert metrics.total_requests == 1
        assert metrics.successful_requests == 0
        assert metrics.failed_requests == 1
        assert metrics.success_rate == 0.0
        assert metrics.last_error == "Connection timeout"
        assert metrics.last_error_time is not None
    
    def test_mixed_success_and_failure(self):
        """Test mixed success and failure recording."""
        metrics = PeerMetrics()
        metrics.record_success(100.0)
        metrics.record_failure("Error")
        metrics.record_success(150.0)
        
        assert metrics.total_requests == 3
        assert metrics.successful_requests == 2
        assert metrics.failed_requests == 1
        assert metrics.success_rate == 2/3


class TestPeerInfo:
    """Test PeerInfo with metrics and timeout."""
    
    def test_peer_info_defaults(self):
        """Test PeerInfo default values."""
        peer = PeerInfo(
            host="192.168.1.100",
            port=17615,
            name="test-peer",
            version="0.1.0",
            instances=2,
            model_id="qwen:7b:q4",
            hardware_summary="Apple M1 Pro",
            last_seen=datetime.now()
        )
        
        assert peer.timeout_seconds == 60.0  # Default timeout
        assert peer.metrics is not None
        assert isinstance(peer.metrics, PeerMetrics)
        assert peer.api_url == "http://192.168.1.100:17615"
    
    def test_peer_info_custom_timeout(self):
        """Test PeerInfo with custom timeout."""
        peer = PeerInfo(
            host="192.168.1.100",
            port=17615,
            name="slow-peer",
            version="0.1.0",
            instances=1,
            model_id="test-model",
            hardware_summary="CPU only",
            last_seen=datetime.now(),
            timeout_seconds=120.0  # Custom timeout
        )
        
        assert peer.timeout_seconds == 120.0


class TestFederationClient:
    """Test FederationClient with peer-specific timeouts."""
    
    @pytest.fixture
    def client(self):
        return FederationClient(timeout=60.0)
    
    @pytest.fixture
    def fast_peer(self):
        return PeerInfo(
            host="192.168.1.10",
            port=17615,
            name="fast-peer",
            version="0.1.0",
            instances=2,
            model_id="qwen:7b:q4",
            hardware_summary="Apple M1 Max",
            last_seen=datetime.now(),
            timeout_seconds=30.0  # Fast peer with short timeout
        )
    
    @pytest.fixture
    def slow_peer(self):
        return PeerInfo(
            host="192.168.1.11",
            port=17615,
            name="slow-peer",
            version="0.1.0",
            instances=1,
            model_id="qwen:7b:q4",
            hardware_summary="CPU only",
            last_seen=datetime.now(),
            timeout_seconds=90.0  # Slow peer with longer timeout
        )
    
    def test_peer_timeout_override(self, client, fast_peer, slow_peer):
        """Test that peer-specific timeout overrides default."""
        # The client should use the peer's timeout, not the default
        assert fast_peer.timeout_seconds == 30.0
        assert slow_peer.timeout_seconds == 90.0
        assert client.timeout == 60.0  # Default unchanged
    
    def test_metrics_updated_on_success(self, fast_peer):
        """Test that metrics are updated on successful request."""
        assert fast_peer.metrics.total_requests == 0
        
        # Simulate recording a success (this would happen in request_vote)
        fast_peer.metrics.record_success(150.0)
        
        assert fast_peer.metrics.total_requests == 1
        assert fast_peer.metrics.successful_requests == 1
        assert fast_peer.metrics.success_rate == 1.0
    
    def test_metrics_updated_on_failure(self, slow_peer):
        """Test that metrics are updated on failed request."""
        assert slow_peer.metrics.total_requests == 0
        
        # Simulate recording a failure
        slow_peer.metrics.record_failure("Connection refused")
        
        assert slow_peer.metrics.total_requests == 1
        assert slow_peer.metrics.failed_requests == 1
        assert slow_peer.metrics.success_rate == 0.0
        assert slow_peer.metrics.last_error == "Connection refused"