local_swarm/tests/test_hardware_detector.py

"""Tests for hardware detection and GPU layer configuration."""

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

import pytest
from unittest.mock import Mock, patch, MagicMock
from hardware.detector import (
    GPUInfo, HardwareProfile, detect_nvidia_gpu, 
    calculate_gpu_layers, validate_gpu_layers, is_android
)


class TestNvidiaGPU:
    """Test NVIDIA GPU detection."""
    
    def test_detect_nvidia_gpu_success(self):
        """Test successful NVIDIA GPU detection."""
        # Mock the entire import system
        mock_pynvml = Mock()
        mock_pynvml.nvmlInit = Mock()
        mock_pynvml.nvmlShutdown = Mock()
        mock_pynvml.nvmlDeviceGetCount = Mock(return_value=1)
        
        # Mock device handle and info
        mock_handle = Mock()
        mock_pynvml.nvmlDeviceGetHandleByIndex = Mock(return_value=mock_handle)
        mock_pynvml.nvmlDeviceGetName = Mock(return_value="NVIDIA GeForce RTX 3080")
        
        # Mock memory info
        mock_mem = Mock()
        mock_mem.total = 10737418240  # 10 GB
        mock_pynvml.nvmlDeviceGetMemoryInfo = Mock(return_value=mock_mem)
        
        # Mock driver version
        mock_pynvml.nvmlSystemGetDriverVersion = Mock(return_value="535.104.05")
        
        # Mock compute capability
        mock_pynvml.nvmlDeviceGetCudaComputeCapability = Mock(return_value=(8, 6))
        
        # Patch __import__ to return our mock
        def mock_import(name, *args, **kwargs):
            if name == 'pynvml':
                return mock_pynvml
            return __builtins__.__import__(name, *args, **kwargs)
        
        with patch('builtins.__import__', side_effect=mock_import):
            gpu = detect_nvidia_gpu()
        
        assert gpu is not None
        assert gpu.name == "NVIDIA GeForce RTX 3080"
        assert gpu.vram_gb == 10.0
        assert gpu.driver_version == "535.104.05"
        assert gpu.is_nvidia is True
        assert gpu.compute_capability == "8.6"
        assert gpu.device_count == 1
    
    def test_detect_nvidia_gpu_no_gpu(self):
        """Test detection when no NVIDIA GPU present."""
        mock_pynvml = Mock()
        mock_pynvml.nvmlInit = Mock()
        mock_pynvml.nvmlShutdown = Mock()
        mock_pynvml.nvmlDeviceGetCount = Mock(return_value=0)
        
        def mock_import(name, *args, **kwargs):
            if name == 'pynvml':
                return mock_pynvml
            return __builtins__.__import__(name, *args, **kwargs)
        
        with patch('builtins.__import__', side_effect=mock_import):
            gpu = detect_nvidia_gpu()
        
        assert gpu is None
    
    def test_detect_nvidia_gpu_import_error(self):
        """Test detection when pynvml is not installed."""
        def mock_import(name, *args, **kwargs):
            if name == 'pynvml':
                raise ImportError("No module named 'pynvml'")
            return __builtins__.__import__(name, *args, **kwargs)
        
        with patch('builtins.__import__', side_effect=mock_import):
            gpu = detect_nvidia_gpu()
        
        assert gpu is None


class TestGPULayerCalculation:
    """Test GPU layer auto-configuration."""
    
    def test_calculate_gpu_layers_apple_silicon(self):
        """Test layer calculation for Apple Silicon."""
        gpu = GPUInfo(
            name="Apple Silicon GPU",
            vram_gb=32.0,
            is_apple_silicon=True
        )
        assert calculate_gpu_layers(gpu) == -1
    
    def test_calculate_gpu_layers_nvidia(self):
        """Test layer calculation for NVIDIA GPU."""
        gpu = GPUInfo(
            name="NVIDIA GeForce RTX 3080",
            vram_gb=10.0,
            is_nvidia=True,
            compute_capability="8.6"
        )
        assert calculate_gpu_layers(gpu) == -1
    
    def test_calculate_gpu_layers_old_nvidia(self):
        """Test layer calculation for old NVIDIA GPU."""
        gpu = GPUInfo(
            name="NVIDIA GeForce GTX 680",
            vram_gb=2.0,
            is_nvidia=True,
            compute_capability="3.0"
        )
        assert calculate_gpu_layers(gpu) == 0  # Too old
    
    def test_calculate_gpu_layers_no_gpu(self):
        """Test layer calculation with no GPU."""
        assert calculate_gpu_layers(None) == 0
    
    def test_validate_gpu_layers_success(self):
        """Test successful layer validation."""
        gpu = GPUInfo(
            name="NVIDIA GeForce RTX 3080",
            vram_gb=10.0,
            is_nvidia=True,
            compute_capability="8.6"
        )
        assert validate_gpu_layers(-1, gpu) == -1
    
    def test_validate_gpu_layers_no_gpu_error(self):
        """Test validation error when GPU requested but none available."""
        with pytest.raises(ValueError, match="no GPU detected"):
            validate_gpu_layers(-1, None)
    
    def test_validate_gpu_layers_old_gpu_error(self):
        """Test validation error for unsupported GPU."""
        gpu = GPUInfo(
            name="NVIDIA GeForce GTX 680",
            vram_gb=2.0,
            is_nvidia=True,
            compute_capability="3.0"
        )
        with pytest.raises(ValueError, match="Minimum required is 5.0"):
            validate_gpu_layers(-1, gpu)


class TestAndroidDetection:
    """Test Android platform detection."""
    
    @patch.dict('os.environ', {'ANDROID_ROOT': '/system'}, clear=True)
    @patch('os.path.exists')
    def test_is_android_env_var(self, mock_exists):
        """Test Android detection via environment variables."""
        mock_exists.return_value = False
        assert is_android() is True
    
    @patch.dict('os.environ', {}, clear=True)
    @patch('os.path.exists')
    def test_is_android_paths(self, mock_exists):
        """Test Android detection via filesystem paths."""
        def exists_side_effect(path):
            return path == "/system/build.prop"
        mock_exists.side_effect = exists_side_effect
        assert is_android() is True
    
    @patch.dict('os.environ', {}, clear=True)
    @patch('os.path.exists')
    def test_is_not_android(self, mock_exists):
        """Test non-Android system."""
        mock_exists.return_value = False
        assert is_android() is False