tests/unit/test_hardware.py

"""
Unit tests for Quantum Hardware Interface

Tests for ID Quantique, QuintessenceLabs, and other hardware adapters.
"""

import pytest
import asyncio
from unittest.mock import Mock, patch, MagicMock, AsyncMock
import sys
from pathlib import Path
import time

sys.path.append(str(Path(__file__).parent.parent.parent))

from app.quantum.hardware_interface import (
    QuantumDeviceType,
    QuantumMeasurement,
    QuantumHardwareInterface,
    PhotonicQRNG,
    SuperconductingQRNG,
    SimulatedQRNG,
    IDQuantiqueQRNG,
    QuintessenceLabsQRNG,
    QuantumHardwareManager,
    get_quantum_hardware_manager
)


class TestQuantumMeasurement:
    """Test QuantumMeasurement dataclass"""

    def test_measurement_creation(self):
        """Test creating a measurement"""
        measurement = QuantumMeasurement(
            value=42,
            bits=8,
            timestamp=time.time(),
            device_id="test_device",
            raw_data=b'\x2a',
            confidence=0.95
        )

        assert measurement.value == 42
        assert measurement.bits == 8
        assert measurement.device_id == "test_device"
        assert measurement.confidence == 0.95
        assert len(measurement.raw_data) == 1


@pytest.mark.asyncio
class TestSimulatedQRNG:
    """Tests for SimulatedQRNG"""

    @pytest.fixture
    def sim_qrng(self):
        """Create simulated QRNG"""
        return SimulatedQRNG(backend="qrisp")

    async def test_initialization(self, sim_qrng):
        """Test simulated QRNG initialization"""
        result = await sim_qrng.initialize()
        assert result is True
        assert sim_qrng.is_connected is True

    async def test_measure_qubits(self, sim_qrng):
        """Test qubit measurement"""
        await sim_qrng.initialize()
        measurement = await sim_qrng.measure_qubits(64)

        assert isinstance(measurement, QuantumMeasurement)
        assert measurement.bits == 64
        assert len(measurement.raw_data) == 8  # 64 bits = 8 bytes
        assert measurement.device_id.startswith("sim_")
        assert measurement.confidence > 0

    async def test_get_device_status(self, sim_qrng):
        """Test device status"""
        status = await sim_qrng.get_device_status()

        assert status["status"] == "operational"
        assert status["device_type"] == QuantumDeviceType.SIMULATOR.value
        assert status["is_real_hardware"] is False

    async def test_calibration(self, sim_qrng):
        """Test calibration"""
        result = await sim_qrng.calibrate()
        assert result is True
        assert sim_qrng.last_calibration is not None


@pytest.mark.asyncio
class TestPhotonicQRNG:
    """Tests for PhotonicQRNG"""

    @pytest.fixture
    def photonic_qrng(self):
        """Create photonic QRNG"""
        return PhotonicQRNG(device_address="usb://0")

    async def test_initialization(self, photonic_qrng):
        """Test photonic QRNG initialization"""
        result = await photonic_qrng.initialize()
        assert result is True
        assert photonic_qrng.is_connected is True

    async def test_measure_qubits(self, photonic_qrng):
        """Test qubit measurement"""
        await photonic_qrng.initialize()
        measurement = await photonic_qrng.measure_qubits(128)

        assert isinstance(measurement, QuantumMeasurement)
        assert measurement.bits == 128
        assert len(measurement.raw_data) == 16  # 128 bits = 16 bytes
        assert measurement.confidence == 0.98

    async def test_get_device_status(self, photonic_qrng):
        """Test device status"""
        await photonic_qrng.initialize()
        status = await photonic_qrng.get_device_status()

        assert status["status"] == "operational"
        assert status["device_type"] == QuantumDeviceType.PHOTONIC.value
        assert "generation_rate_bps" in status
        assert status["generation_rate_bps"] == 4_000_000

    async def test_disconnected_measurement(self, photonic_qrng):
        """Test measurement when disconnected"""
        with pytest.raises(RuntimeError, match="not connected"):
            await photonic_qrng.measure_qubits(64)


@pytest.mark.asyncio
class TestSuperconductingQRNG:
    """Tests for SuperconductingQRNG"""

    @pytest.fixture
    def sc_qrng(self):
        """Create superconducting QRNG"""
        return SuperconductingQRNG(device_address="tcp://localhost:8080")

    async def test_initialization(self, sc_qrng):
        """Test superconducting QRNG initialization"""
        result = await sc_qrng.initialize()
        assert result is True
        assert sc_qrng.is_connected is True

    async def test_measure_qubits(self, sc_qrng):
        """Test qubit measurement"""
        await sc_qrng.initialize()
        measurement = await sc_qrng.measure_qubits(256)

        assert isinstance(measurement, QuantumMeasurement)
        assert measurement.bits == 256
        assert len(measurement.raw_data) == 32  # 256 bits = 32 bytes
        assert measurement.confidence == 0.99

    async def test_device_status(self, sc_qrng):
        """Test device status"""
        await sc_qrng.initialize()
        status = await sc_qrng.get_device_status()

        assert status["status"] == "operational"
        assert status["device_type"] == QuantumDeviceType.SUPERCONDUCTING.value
        assert status["temperature"] == 0.1  # Near absolute zero
        assert status["generation_rate_bps"] == 10_000_000


@pytest.mark.asyncio
class TestIDQuantiqueQRNG:
    """Tests for IDQuantiqueQRNG"""

    @pytest.fixture
    def idq_qrng(self):
        """Create ID Quantique QRNG"""
        return IDQuantiqueQRNG(device_address="usb://0", device_type="usb")

    async def test_initialization(self, idq_qrng):
        """Test ID Quantique initialization"""
        result = await idq_qrng.initialize()
        assert result is True
        assert idq_qrng.is_connected is True
        assert idq_qrng.device_id.startswith("idq_")

    async def test_measure_qubits(self, idq_qrng):
        """Test qubit measurement"""
        await idq_qrng.initialize()
        measurement = await idq_qrng.measure_qubits(512)

        assert isinstance(measurement, QuantumMeasurement)
        assert measurement.bits == 512
        assert len(measurement.raw_data) == 64  # 512 bits = 64 bytes
        assert measurement.confidence == 0.99

    async def test_device_status(self, idq_qrng):
        """Test device status"""
        await idq_qrng.initialize()
        status = await idq_qrng.get_device_status()

        assert status["status"] == "operational"
        assert status["vendor"] == "ID Quantique"
        assert status["model"] == "Quantis"
        assert status["device_type"] == QuantumDeviceType.PHOTONIC.value

    async def test_calibration(self, idq_qrng):
        """Test calibration"""
        result = await idq_qrng.calibrate()
        assert result is True
        assert idq_qrng.last_calibration is not None


@pytest.mark.asyncio
class TestQuintessenceLabsQRNG:
    """Tests for QuintessenceLabsQRNG"""

    @pytest.fixture
    def qlabs_qrng(self):
        """Create QuintessenceLabs QRNG"""
        return QuintessenceLabsQRNG(
            device_address="tcp://localhost:8888",
            api_key="test_api_key"
        )

    async def test_initialization(self, qlabs_qrng):
        """Test QuintessenceLabs initialization"""
        result = await qlabs_qrng.initialize()
        assert result is True
        assert qlabs_qrng.is_connected is True
        assert qlabs_qrng.device_id.startswith("qlabs_")

    async def test_measure_qubits(self, qlabs_qrng):
        """Test qubit measurement"""
        await qlabs_qrng.initialize()
        measurement = await qlabs_qrng.measure_qubits(1024)

        assert isinstance(measurement, QuantumMeasurement)
        assert measurement.bits == 1024
        assert len(measurement.raw_data) == 128  # 1024 bits = 128 bytes
        assert measurement.confidence == 0.995

    async def test_device_status(self, qlabs_qrng):
        """Test device status"""
        await qlabs_qrng.initialize()
        status = await qlabs_qrng.get_device_status()

        assert status["status"] == "operational"
        assert status["vendor"] == "QuintessenceLabs"
        assert status["model"] == "qStream"
        assert status["generation_rate_bps"] == 64_000_000


class TestQuantumHardwareManager:
    """Tests for QuantumHardwareManager"""

    @pytest.fixture
    def hw_manager(self):
        """Create hardware manager"""
        return QuantumHardwareManager()

    @pytest.mark.asyncio
    async def test_add_device(self, hw_manager):
        """Test adding a device"""
        device = SimulatedQRNG(backend="test")
        result = await hw_manager.add_device("test_device", device)

        assert result is True
        assert "test_device" in hw_manager.devices
        assert hw_manager.active_device_id == "test_device"

    @pytest.mark.asyncio
    async def test_add_duplicate_device(self, hw_manager):
        """Test adding duplicate device"""
        device = SimulatedQRNG(backend="test")
        await hw_manager.add_device("test_device", device)

        # Try to add again
        result = await hw_manager.add_device("test_device", device)
        assert result is False

    @pytest.mark.asyncio
    async def test_remove_device(self, hw_manager):
        """Test removing a device"""
        device = SimulatedQRNG(backend="test")
        await hw_manager.add_device("test_device", device)

        result = await hw_manager.remove_device("test_device")
        assert result is True
        assert "test_device" not in hw_manager.devices

    @pytest.mark.asyncio
    async def test_measure_qubits(self, hw_manager):
        """Test measurement through manager"""
        device = SimulatedQRNG(backend="test")
        await hw_manager.add_device("test_device", device)

        measurement = await hw_manager.measure_qubits(64)

        assert isinstance(measurement, QuantumMeasurement)
        assert measurement.bits == 64

    @pytest.mark.asyncio
    async def test_measure_no_devices(self, hw_manager):
        """Test measurement with no devices"""
        with pytest.raises(RuntimeError, match="No quantum devices"):
            await hw_manager.measure_qubits(64)

    @pytest.mark.asyncio
    async def test_get_device_status(self, hw_manager):
        """Test getting device status"""
        device = SimulatedQRNG(backend="test")
        await hw_manager.add_device("test_device", device)

        status = await hw_manager.get_device_status("test_device")
        assert status["status"] == "operational"

    @pytest.mark.asyncio
    async def test_get_all_statuses(self, hw_manager):
        """Test getting all device statuses"""
        device1 = SimulatedQRNG(backend="test1")
        device2 = SimulatedQRNG(backend="test2")

        await hw_manager.add_device("device1", device1)
        await hw_manager.add_device("device2", device2)

        statuses = await hw_manager.get_device_status()

        assert "device1" in statuses
        assert "device2" in statuses

    @pytest.mark.asyncio
    async def test_calibrate_device(self, hw_manager):
        """Test device calibration"""
        device = SimulatedQRNG(backend="test")
        await hw_manager.add_device("test_device", device)

        result = await hw_manager.calibrate_device("test_device")
        assert result is True

    @pytest.mark.asyncio
    async def test_set_active_device(self, hw_manager):
        """Test setting active device"""
        device1 = SimulatedQRNG(backend="test1")
        device2 = SimulatedQRNG(backend="test2")

        await hw_manager.add_device("device1", device1)
        await hw_manager.add_device("device2", device2)

        result = hw_manager.set_active_device("device2")
        assert result is True
        assert hw_manager.active_device_id == "device2"

    @pytest.mark.asyncio
    async def test_run_entropy_quality_checks(self, hw_manager):
        """Test entropy quality checks"""
        device = SimulatedQRNG(backend="test")
        await hw_manager.add_device("test_device", device)

        quality = await hw_manager.run_entropy_quality_checks("test_device")

        assert "device_id" in quality
        assert "sample_size_bytes" in quality
        assert "chi_square" in quality
        assert "shannon_entropy" in quality
        assert "min_entropy" in quality
        assert "overall_quality" in quality
        assert quality["device_id"] == "test_device"

    @pytest.mark.asyncio
    async def test_run_entropy_checks_no_device(self, hw_manager):
        """Test entropy checks with no device"""
        with pytest.raises(ValueError, match="No valid device"):
            await hw_manager.run_entropy_quality_checks()


@pytest.mark.asyncio
class TestHardwareManagerMultipleDevices:
    """Tests for managing multiple hardware devices"""

    @pytest.fixture
    def hw_manager(self):
        """Create hardware manager with multiple devices"""
        manager = QuantumHardwareManager()

        # Add different types of devices
        sim_device = SimulatedQRNG(backend="qrisp")
        photonic_device = PhotonicQRNG(device_address="usb://0")
        sc_device = SuperconductingQRNG(device_address="tcp://localhost")

        asyncio.get_event_loop().run_until_complete(
            asyncio.gather(
                manager.add_device("sim", sim_device),
                manager.add_device("photonic", photonic_device),
                manager.add_device("superconducting", sc_device)
            )
        )

        return manager

    async def test_available_devices(self, hw_manager):
        """Test listing available devices"""
        devices = hw_manager.get_available_devices()

        assert len(devices) == 3
        assert "sim" in devices
        assert "photonic" in devices
        assert "superconducting" in devices

    async def test_switch_active_device(self, hw_manager):
        """Test switching active device"""
        assert hw_manager.active_device_id == "sim"  # First added

        hw_manager.set_active_device("photonic")
        assert hw_manager.active_device_id == "photonic"

        hw_manager.set_active_device("superconducting")
        assert hw_manager.active_device_id == "superconducting"

    async def test_measure_from_specific_device(self, hw_manager):
        """Test measuring from specific device"""
        measurement = await hw_manager.measure_qubits(64, "photonic")

        assert isinstance(measurement, QuantumMeasurement)
        assert measurement.device_id.startswith("photon_")

    async def test_remove_active_device(self, hw_manager):
        """Test removing active device"""
        await hw_manager.remove_device("sim")

        # Active device should change
        assert hw_manager.active_device_id != "sim"
        assert hw_manager.active_device_id in ["photonic", "superconducting"]


class TestSingletonPattern:
    """Test singleton pattern for hardware manager"""

    def test_get_quantum_hardware_manager(self):
        """Test singleton returns same instance"""
        manager1 = get_quantum_hardware_manager()
        manager2 = get_quantum_hardware_manager()

        assert manager1 is manager2


if __name__ == "__main__":
    pytest.main([__file__, "-v", "-s"])