qssh 0.0.2-alpha

use qssh::qkd::{QkdProvider, MockQkdProvider};
use qssh::qkd::entropy::{QuantumEntropyProvider, EntropySource};

#[tokio::test]
async fn test_mock_qkd_provider() {
    let provider = MockQkdProvider::new();
    
    // Test getting a key
    let key = provider.get_key("test-key-id", 32)
        .await.expect("Failed to get QKD key");
    
    assert_eq!(key.len(), 32);
    
    // Different key IDs should give different keys
    let key2 = provider.get_key("different-key-id", 32)
        .await.expect("Failed to get QKD key");
    
    assert_ne!(key, key2);
}

#[tokio::test]
async fn test_qkd_key_sizes() {
    let provider = MockQkdProvider::new();
    
    let sizes = vec![16, 32, 64, 128, 256];
    
    for size in sizes {
        let key = provider.get_key("size-test", size)
            .await.expect("Failed to get QKD key");
        
        assert_eq!(key.len(), size, "Key size mismatch for size {}", size);
    }
}

#[tokio::test]
async fn test_quantum_entropy_provider() {
    let provider = QuantumEntropyProvider::new();
    assert!(provider.is_ok(), "Failed to create entropy provider");
    
    let provider = provider.unwrap();
    
    // Test getting entropy
    let entropy = provider.get_entropy(64).await;
    assert!(entropy.is_ok(), "Failed to get entropy");
    
    let entropy = entropy.unwrap();
    assert_eq!(entropy.len(), 64);
    
    // Two calls should give different results
    let entropy2 = provider.get_entropy(64).await.expect("Failed to get entropy");
    assert_ne!(entropy, entropy2, "Entropy should be random");
}

#[tokio::test]
async fn test_entropy_sources() {
    let provider = QuantumEntropyProvider::new().expect("Failed to create provider");
    
    let sources = provider.available_sources().await;
    
    // Should always have at least system RNG
    assert!(!sources.is_empty(), "No entropy sources available");
    assert!(sources.contains(&EntropySource::SystemRng), "System RNG should be available");
}

#[tokio::test]
async fn test_mixed_entropy() {
    let provider = QuantumEntropyProvider::new().expect("Failed to create provider");
    
    // Get entropy multiple times and check uniqueness
    let mut samples = Vec::new();
    
    for _ in 0..10 {
        let entropy = provider.get_entropy(32).await.expect("Failed to get entropy");
        samples.push(entropy);
    }
    
    // All samples should be unique
    for i in 0..samples.len() {
        for j in (i + 1)..samples.len() {
            assert_ne!(samples[i], samples[j], "Duplicate entropy detected at {} and {}", i, j);
        }
    }
}

#[cfg(test)]
mod qkd_stark_tests {
    use super::*;
    use qssh::qkd::stark_integration::StarkProof;
    
    #[test]
    fn test_stark_proof_structure() {
        // This would test STARK proof generation if implemented
        let proof = StarkProof {
            commitment: vec![0; 32],
            evaluations: vec![vec![0; 32]],
            merkle_paths: vec![],
            fri_layers: vec![],
        };
        
        assert_eq!(proof.commitment.len(), 32);
        assert!(!proof.evaluations.is_empty());
    }
    
    #[test]
    fn test_stark_verify_stub() {
        use qssh::qkd::stark_integration::verify_stark_proof;
        
        let proof = StarkProof {
            commitment: vec![1; 32],
            evaluations: vec![vec![2; 32]],
            merkle_paths: vec![],
            fri_layers: vec![],
        };
        
        let public_input = vec![3; 32];
        
        // This is currently stubbed but should not panic
        let result = verify_stark_proof(&proof, &public_input);
        assert!(result);
    }
}