shadow_load_testing/

stress.rs

//! Stress test operations for DHT, messaging, storage, and crypto

use shadow_core::{PeerId, PeerInfo};
use crate::swarm::VirtualSwarm;

/// Configurable stress test runner
pub struct StressTest {
    iterations: usize,
    results: Vec<StressResult>,
}

/// Result of a single stress test
#[derive(Debug, Clone)]
pub struct StressResult {
    pub name: String,
    pub iterations: usize,
    pub successes: usize,
    pub failures: usize,
    pub elapsed: std::time::Duration,
}

impl StressResult {
    pub fn success_rate(&self) -> f64 {
        if self.iterations == 0 {
            return 0.0;
        }
        self.successes as f64 / self.iterations as f64 * 100.0
    }

    pub fn ops_per_sec(&self) -> f64 {
        let secs = self.elapsed.as_secs_f64();
        if secs == 0.0 {
            return 0.0;
        }
        self.iterations as f64 / secs
    }
}

impl StressTest {
    pub fn new(iterations: usize) -> Self {
        StressTest {
            iterations,
            results: Vec::new(),
        }
    }

    pub fn iterations(&self) -> usize {
        self.iterations
    }

    pub fn results(&self) -> &[StressResult] {
        &self.results
    }

    pub fn add_result(&mut self, result: StressResult) {
        self.results.push(result);
    }

    pub fn all_passed(&self) -> bool {
        self.results.iter().all(|r| r.success_rate() > 99.0)
    }
}

/// Stress test DHT store/retrieve operations
pub fn stress_dht_operations(swarm: &VirtualSwarm, ops: usize) -> bool {
    use bytes::Bytes;

    let mut store = dht::DHTStore::default();
    let mut successes = 0;

    // Store phase
    let entries: Vec<([u8; 32], Bytes)> = (0..ops)
        .map(|i| {
            let mut key = [0u8; 32];
            let i_bytes = (i as u64).to_le_bytes();
            key[..8].copy_from_slice(&i_bytes);
            let value = Bytes::from(format!("stress-value-{}", i).into_bytes());
            (key, value)
        })
        .collect();

    for (key, value) in &entries {
        let publisher = [0u8; 32];
        let stored = dht::StoredValue::new(value.clone(), publisher, 3600);
        if store.put(*key, stored).is_ok() {
            successes += 1;
        }
    }

    // Retrieve phase
    for (key, expected_value) in &entries {
        if let Some(retrieved) = store.get(key) {
            if retrieved.data == *expected_value {
                successes += 1;
            }
        }
    }

    // Each op has a store + retrieve = 2 * ops successes expected
    successes >= ops * 2 * 99 / 100
}

/// Stress test message routing across the swarm
pub fn stress_message_routing(swarm: &VirtualSwarm, messages: usize) -> bool {
    use rand::Rng;
    let mut rng = rand::thread_rng();
    let peer_count = swarm.peer_count();

    if peer_count < 2 {
        return false;
    }

    let mut successes = 0;

    for _ in 0..messages {
        let sender_idx = rng.gen_range(0..peer_count);
        let target = PeerId::random();

        // Simulate routing: find closest peers from sender's perspective
        let closest = swarm.iterative_lookup(sender_idx, &target, 20);
        if !closest.is_empty() {
            successes += 1;
        }
    }

    // At least 80% should find some route
    successes >= messages * 80 / 100
}

/// Stress test storage operations
pub fn stress_storage_operations(items: usize) -> bool {
    let store = storage::ContentStore::default();
    let mut successes = 0;

    for i in 0..items {
        let data = format!("stress-content-{}-{}", i, "x".repeat(100)).into_bytes();
        match store.store(&data) {
            Ok(id) => {
                if let Ok(retrieved) = store.retrieve(&id) {
                    if retrieved.as_ref() == data.as_slice() {
                        successes += 1;
                    }
                }
            }
            Err(_) => {}
        }
    }

    successes >= items * 99 / 100
}

/// Stress test concurrent secure channel creation
pub fn stress_concurrent_channels(count: usize) -> bool {
    let mut successes = 0;

    for _ in 0..count {
        let a_sk = crypto::SigningKey::generate();
        let a_id = PeerId::random();
        let b_sk = crypto::SigningKey::generate();
        let b_id = PeerId::random();

        let a_vk = a_sk.verify_key();
        let b_vk = b_sk.verify_key();

        let (a_state, a_pub) = messaging::SecureChannel::initiate(a_sk, a_id);
        let (b_state, b_pub) = messaging::SecureChannel::initiate(b_sk, b_id);

        if let (Ok(a_chan), Ok(b_chan)) = (
            messaging::SecureChannel::complete(a_state, &b_pub, b_vk),
            messaging::SecureChannel::complete(b_state, &a_pub, a_vk),
        ) {
            let test_msg = messaging::Message::text(
                a_id,
                messaging::MessageTarget::Direct(b_id),
                "stress test message",
            );
            if let Ok(env) = a_chan.encrypt_message(&test_msg) {
                if let Ok(dec) = b_chan.decrypt_message(&env) {
                    if dec.sender == a_id {
                        successes += 1;
                    }
                }
            }
        }
    }

    successes >= count * 99 / 100
}

/// Stress test steganography encode/decode cycles
pub fn stress_stego_operations(cycles: usize) -> bool {
    let mut successes = 0;

    for i in 0..cycles {
        let data = format!("stego-stress-{}", i).into_bytes();
        let config = stego_transport::StegoChannelConfig::default();
        let channel = stego_transport::StegoChannel::new(config);

        match channel.encode(&data) {
            Ok(encoded) => {
                match channel.decode(&encoded) {
                    Ok(decoded) => {
                        if decoded.len() >= data.len() && decoded[..data.len()] == data[..] {
                            successes += 1;
                        }
                    }
                    Err(_) => {}
                }
            }
            Err(_) => {}
        }
    }

    successes >= cycles * 95 / 100
}

/// Stress test DHT replication under churn
pub fn stress_replication_churn(peer_count: usize, churn_rounds: usize) -> bool {
    use dht::replication::{ReplicationManager, ReplicationConfig};
    use bytes::Bytes;

    let config = ReplicationConfig::default();
    let mut manager = ReplicationManager::new(config);

    let peers: Vec<PeerInfo> = (0..peer_count)
        .map(|i| {
            PeerInfo::new(
                PeerId::random(),
                vec![format!("127.0.0.1:{}", 20000 + i)],
                [0u8; 32],
                [0u8; 32],
            )
        })
        .collect();

    // Store data and schedule replication
    let data_key = [0xBBu8; 32];
    let data_value = Bytes::from(b"stress-repl-value".to_vec());
    let tasks = manager.schedule_replication(data_key, data_value, &peers[..3.min(peer_count)]);

    // Confirm initial replications
    for task in &tasks {
        manager.confirm_replication(data_key, task.target_peer);
    }

    // Verify initial replication
    let initial_count = manager.replica_count(&data_key);
    initial_count > 0
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_stress_dht() {
        let mut swarm = VirtualSwarm::new(100);
        swarm.bootstrap(10);
        assert!(stress_dht_operations(&swarm, 100));
    }

    #[test]
    fn test_stress_routing() {
        let mut swarm = VirtualSwarm::new(100);
        swarm.bootstrap(10);
        assert!(stress_message_routing(&swarm, 50));
    }

    #[test]
    fn test_stress_storage() {
        assert!(stress_storage_operations(50));
    }

    #[test]
    fn test_stress_channels() {
        assert!(stress_concurrent_channels(10));
    }

    #[test]
    fn test_stress_stego() {
        assert!(stress_stego_operations(10));
    }

    #[test]
    fn test_stress_replication() {
        assert!(stress_replication_churn(50, 10));
    }

    #[test]
    fn test_stress_test_runner() {
        let mut test = StressTest::new(100);
        test.add_result(StressResult {
            name: "test_op".to_string(),
            iterations: 100,
            successes: 100,
            failures: 0,
            elapsed: std::time::Duration::from_millis(50),
        });
        assert!(test.all_passed());
        assert_eq!(test.results()[0].success_rate(), 100.0);
        assert!(test.results()[0].ops_per_sec() > 0.0);
    }
}