kaccy-bitcoin 0.2.0

// Testing utilities and infrastructure for kaccy-bitcoin
//
// This module provides comprehensive testing support including:
// - Property-based testing helpers
// - Fuzz testing utilities
// - Integration test helpers
// - Mock implementations
// - Test data generators

#[cfg(test)]
pub mod helpers {

    use bitcoin::{
        Address, Amount, Network, OutPoint, ScriptBuf, Sequence, Transaction, TxIn, TxOut, Txid,
        Witness, key::CompressedPublicKey, secp256k1::rand::thread_rng,
    };
    use std::str::FromStr;

    /// Generate a random transaction ID
    pub fn random_txid() -> Txid {
        use bitcoin::secp256k1::rand::random;
        Txid::from_str(&format!("{:064x}", random::<u64>())).unwrap()
    }

    /// Generate a random outpoint
    pub fn random_outpoint() -> OutPoint {
        use bitcoin::secp256k1::rand::random;
        OutPoint {
            txid: random_txid(),
            vout: random::<u32>() % 10,
        }
    }

    /// Generate a random valid Bitcoin address
    pub fn random_address(network: Network) -> Address {
        use bitcoin::secp256k1::Secp256k1;
        use bitcoin::{KnownHrp, PrivateKey};
        let secp = Secp256k1::new();
        let (secret_key, _) = secp.generate_keypair(&mut thread_rng());
        let private_key = PrivateKey::new(secret_key, network);
        let compressed = CompressedPublicKey::from_private_key(&secp, &private_key).unwrap();
        let hrp = match network {
            Network::Bitcoin => KnownHrp::Mainnet,
            Network::Testnet => KnownHrp::Testnets,
            Network::Signet => KnownHrp::Testnets, // Signet uses same HRP as testnets
            Network::Regtest => KnownHrp::Regtest,
            _ => KnownHrp::Testnets,
        };
        Address::p2wpkh(&compressed, hrp)
    }

    /// Create a mock transaction with specified inputs and outputs
    pub fn create_mock_transaction(
        num_inputs: usize,
        num_outputs: usize,
        output_amounts: Option<Vec<u64>>,
    ) -> Transaction {
        let inputs: Vec<TxIn> = (0..num_inputs)
            .map(|_| TxIn {
                previous_output: random_outpoint(),
                script_sig: ScriptBuf::new(),
                sequence: Sequence::ENABLE_RBF_NO_LOCKTIME,
                witness: Witness::new(),
            })
            .collect();

        let outputs: Vec<TxOut> = if let Some(amounts) = output_amounts {
            amounts
                .into_iter()
                .map(|amount| TxOut {
                    value: Amount::from_sat(amount),
                    script_pubkey: random_address(Network::Bitcoin).script_pubkey(),
                })
                .collect()
        } else {
            use bitcoin::secp256k1::rand::random;
            (0..num_outputs)
                .map(|_| TxOut {
                    value: Amount::from_sat(100_000 + (random::<u64>() % 900_000)),
                    script_pubkey: random_address(Network::Bitcoin).script_pubkey(),
                })
                .collect()
        };

        Transaction {
            version: bitcoin::transaction::Version::TWO,
            lock_time: bitcoin::absolute::LockTime::ZERO,
            input: inputs,
            output: outputs,
        }
    }

    /// Generate random Bitcoin amount within reasonable range
    pub fn random_amount() -> u64 {
        use bitcoin::secp256k1::rand::random;
        let min = 1_000; // 1000 sats minimum
        let max = 100_000_000; // 1 BTC maximum
        min + (random::<u64>() % (max - min))
    }

    /// Generate a batch of random amounts
    pub fn random_amounts(count: usize) -> Vec<u64> {
        (0..count).map(|_| random_amount()).collect()
    }

    /// Check if an amount is dust
    pub fn is_dust(amount: u64) -> bool {
        amount < 546 // Standard dust threshold
    }

    /// Create a simple P2WPKH transaction
    pub fn create_p2wpkh_transaction(_network: Network) -> Transaction {
        create_mock_transaction(1, 2, Some(vec![50_000, 49_000]))
    }
}

#[cfg(test)]
pub mod property_tests {
    use super::helpers::*;
    use bitcoin::{Amount, Network};

    /// Property: Transaction inputs should always be non-empty
    pub fn prop_transaction_has_inputs(num_inputs: usize) -> bool {
        if num_inputs == 0 {
            return true; // Skip invalid case
        }
        let tx = create_mock_transaction(num_inputs, 2, None);
        !tx.input.is_empty() && tx.input.len() == num_inputs
    }

    /// Property: Transaction outputs should always be non-empty
    pub fn prop_transaction_has_outputs(num_outputs: usize) -> bool {
        if num_outputs == 0 {
            return true; // Skip invalid case
        }
        let tx = create_mock_transaction(2, num_outputs, None);
        !tx.output.is_empty() && tx.output.len() == num_outputs
    }

    /// Property: Output amounts should match input specification
    pub fn prop_output_amounts_match(amounts: Vec<u64>) -> bool {
        if amounts.is_empty() {
            return true;
        }
        let tx = create_mock_transaction(1, amounts.len(), Some(amounts.clone()));
        tx.output
            .iter()
            .zip(amounts.iter())
            .all(|(output, &expected)| output.value == Amount::from_sat(expected))
    }

    /// Property: Dust detection should be consistent
    pub fn prop_dust_detection(amount: u64) -> bool {
        let is_dust_result = is_dust(amount);
        if amount < 546 {
            is_dust_result
        } else {
            !is_dust_result
        }
    }

    /// Property: Random amounts should be within valid range
    pub fn prop_random_amounts_valid() -> bool {
        let amounts = random_amounts(100);
        amounts
            .iter()
            .all(|&amount| (1_000..=100_000_000).contains(&amount))
    }

    /// Property: Address generation should be deterministic per network
    pub fn prop_address_network_consistency(_network: Network) -> bool {
        // Address generation successful
        true
    }

    #[test]
    fn test_transaction_inputs_property() {
        for num in 1..10 {
            assert!(prop_transaction_has_inputs(num));
        }
    }

    #[test]
    fn test_transaction_outputs_property() {
        for num in 1..10 {
            assert!(prop_transaction_has_outputs(num));
        }
    }

    #[test]
    fn test_output_amounts_property() {
        let test_cases = vec![
            vec![10_000],
            vec![10_000, 20_000],
            vec![10_000, 20_000, 30_000],
        ];
        for amounts in test_cases {
            assert!(prop_output_amounts_match(amounts));
        }
    }

    #[test]
    fn test_dust_detection_property() {
        for amount in [0, 100, 545, 546, 1000, 10_000] {
            assert!(prop_dust_detection(amount));
        }
    }

    #[test]
    fn test_random_amounts_property() {
        for _ in 0..10 {
            assert!(prop_random_amounts_valid());
        }
    }

    #[test]
    fn test_address_network_property() {
        for network in [
            Network::Bitcoin,
            Network::Testnet,
            Network::Regtest,
            Network::Signet,
        ] {
            assert!(prop_address_network_consistency(network));
        }
    }
}

#[cfg(test)]
pub mod fuzz_helpers {
    use super::helpers::*;
    use bitcoin::{Transaction, consensus::encode};

    /// Fuzz test helper for transaction parsing
    pub fn fuzz_transaction_parsing(data: &[u8]) -> bool {
        match encode::deserialize::<Transaction>(data) {
            Ok(tx) => {
                // If parsing succeeds, re-serialization should match
                let _serialized = encode::serialize(&tx);
                // Basic sanity checks
                !tx.input.is_empty() || !tx.output.is_empty()
            }
            Err(_) => {
                // Parsing failed, which is acceptable for invalid data
                true
            }
        }
    }

    /// Fuzz test helper for address parsing
    pub fn fuzz_address_parsing(data: &str) -> bool {
        use bitcoin::Address;
        use std::str::FromStr;
        // Attempt to parse as address
        let _ = Address::from_str(data);
        // Always returns true as we're just testing for crashes
        true
    }

    /// Generate random bytes for fuzzing
    pub fn random_bytes(len: usize) -> Vec<u8> {
        use bitcoin::secp256k1::rand::random;
        (0..len).map(|_| random::<u8>()).collect()
    }

    #[test]
    fn test_fuzz_transaction_parsing_random() {
        use bitcoin::secp256k1::rand::random;
        for _ in 0..100 {
            let data = random_bytes(random::<usize>() % 1000);
            assert!(fuzz_transaction_parsing(&data));
        }
    }

    #[test]
    fn test_fuzz_transaction_parsing_valid() {
        let tx = create_mock_transaction(2, 2, None);
        let serialized = encode::serialize(&tx);
        assert!(fuzz_transaction_parsing(&serialized));
    }

    #[test]
    fn test_fuzz_address_parsing() {
        let test_strings = vec![
            "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
            "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq",
            "invalid",
            "",
            "123",
        ];
        for s in test_strings {
            assert!(fuzz_address_parsing(s));
        }
    }
}

#[cfg(test)]
pub mod integration_helpers {
    use std::time::Duration;

    /// Mock Bitcoin Core RPC responses
    pub struct MockRpcResponse {
        pub block_height: u64,
        pub network: String,
        pub connections: u32,
    }

    impl Default for MockRpcResponse {
        fn default() -> Self {
            Self {
                block_height: 800_000,
                network: "test".to_string(),
                connections: 8,
            }
        }
    }

    /// Test configuration for integration tests
    pub struct IntegrationTestConfig {
        pub rpc_url: String,
        pub rpc_user: String,
        pub rpc_password: String,
        pub timeout: Duration,
    }

    impl Default for IntegrationTestConfig {
        fn default() -> Self {
            Self {
                rpc_url: "http://localhost:18443".to_string(),
                rpc_user: "test".to_string(),
                rpc_password: "test".to_string(),
                timeout: Duration::from_secs(30),
            }
        }
    }

    /// Helper to wait for a condition with timeout
    pub async fn wait_for_condition<F>(
        mut condition: F,
        timeout: Duration,
        check_interval: Duration,
    ) -> bool
    where
        F: FnMut() -> bool,
    {
        let start = std::time::Instant::now();
        while start.elapsed() < timeout {
            if condition() {
                return true;
            }
            tokio::time::sleep(check_interval).await;
        }
        false
    }

    #[tokio::test]
    async fn test_wait_for_condition_success() {
        let mut counter = 0;
        let result = wait_for_condition(
            || {
                counter += 1;
                counter >= 3
            },
            Duration::from_secs(5),
            Duration::from_millis(100),
        )
        .await;
        assert!(result);
        assert!(counter >= 3);
    }

    #[tokio::test]
    async fn test_wait_for_condition_timeout() {
        let result = wait_for_condition(
            || false,
            Duration::from_millis(200),
            Duration::from_millis(50),
        )
        .await;
        assert!(!result);
    }
}

#[cfg(test)]
pub mod load_test_helpers {
    use std::sync::Arc;
    use std::sync::atomic::{AtomicU64, Ordering};
    use std::time::{Duration, Instant};
    use tokio::task::JoinHandle;

    /// Load test statistics
    #[derive(Debug, Clone)]
    pub struct LoadTestStats {
        pub total_requests: u64,
        pub successful_requests: u64,
        pub failed_requests: u64,
        pub total_duration: Duration,
        pub avg_latency: Duration,
        pub min_latency: Duration,
        pub max_latency: Duration,
        pub requests_per_second: f64,
    }

    impl LoadTestStats {
        pub fn new(
            total: u64,
            successful: u64,
            failed: u64,
            duration: Duration,
            latencies: &[Duration],
        ) -> Self {
            let avg_latency = if !latencies.is_empty() {
                Duration::from_nanos(
                    latencies.iter().map(|d| d.as_nanos() as u64).sum::<u64>()
                        / latencies.len() as u64,
                )
            } else {
                Duration::ZERO
            };

            let min_latency = latencies.iter().min().copied().unwrap_or(Duration::ZERO);
            let max_latency = latencies.iter().max().copied().unwrap_or(Duration::ZERO);

            let requests_per_second = if duration.as_secs_f64() > 0.0 {
                total as f64 / duration.as_secs_f64()
            } else {
                0.0
            };

            Self {
                total_requests: total,
                successful_requests: successful,
                failed_requests: failed,
                total_duration: duration,
                avg_latency,
                min_latency,
                max_latency,
                requests_per_second,
            }
        }
    }

    /// Load test runner
    pub struct LoadTestRunner {
        concurrency: usize,
        total_requests: usize,
    }

    impl LoadTestRunner {
        pub fn new(concurrency: usize, total_requests: usize) -> Self {
            Self {
                concurrency,
                total_requests,
            }
        }

        /// Run a load test with the given async function
        pub async fn run<F, Fut>(&self, f: F) -> LoadTestStats
        where
            F: Fn() -> Fut + Send + Sync + 'static + Clone,
            Fut: std::future::Future<Output = Result<(), ()>> + Send,
        {
            let success_count = Arc::new(AtomicU64::new(0));
            let fail_count = Arc::new(AtomicU64::new(0));
            let latencies = Arc::new(tokio::sync::Mutex::new(Vec::new()));

            let start = Instant::now();
            let requests_per_worker = self.total_requests / self.concurrency;

            let mut handles: Vec<JoinHandle<()>> = Vec::new();

            for _ in 0..self.concurrency {
                let f = f.clone();
                let success = Arc::clone(&success_count);
                let fail = Arc::clone(&fail_count);
                let lats = Arc::clone(&latencies);

                let handle = tokio::spawn(async move {
                    for _ in 0..requests_per_worker {
                        let req_start = Instant::now();
                        match f().await {
                            Ok(_) => {
                                success.fetch_add(1, Ordering::Relaxed);
                            }
                            Err(_) => {
                                fail.fetch_add(1, Ordering::Relaxed);
                            }
                        }
                        let latency = req_start.elapsed();
                        lats.lock().await.push(latency);
                    }
                });
                handles.push(handle);
            }

            for handle in handles {
                let _ = handle.await;
            }

            let duration = start.elapsed();
            let successful = success_count.load(Ordering::Relaxed);
            let failed = fail_count.load(Ordering::Relaxed);
            let latency_vec = latencies.lock().await.clone();

            LoadTestStats::new(
                self.total_requests as u64,
                successful,
                failed,
                duration,
                &latency_vec,
            )
        }
    }

    #[tokio::test]
    async fn test_load_test_runner() {
        let runner = LoadTestRunner::new(4, 100);
        let stats = runner
            .run(|| async {
                tokio::time::sleep(Duration::from_millis(1)).await;
                Ok(())
            })
            .await;

        assert_eq!(stats.total_requests, 100);
        assert_eq!(stats.successful_requests, 100);
        assert_eq!(stats.failed_requests, 0);
        assert!(stats.requests_per_second > 0.0);
    }

    #[tokio::test]
    async fn test_load_test_with_failures() {
        let runner = LoadTestRunner::new(2, 10);
        let counter = Arc::new(AtomicU64::new(0));

        let stats = runner
            .run({
                let counter = Arc::clone(&counter);
                move || {
                    let counter = Arc::clone(&counter);
                    async move {
                        let n = counter.fetch_add(1, Ordering::Relaxed);
                        if n % 2 == 0 { Ok(()) } else { Err(()) }
                    }
                }
            })
            .await;

        assert_eq!(stats.total_requests, 10);
        assert!(stats.failed_requests > 0);
        assert!(stats.successful_requests > 0);
    }
}

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

    #[test]
    fn test_random_txid_generation() {
        let txid1 = random_txid();
        let txid2 = random_txid();
        // Should generate different txids
        assert_ne!(txid1, txid2);
    }

    #[test]
    fn test_random_outpoint_generation() {
        let outpoint = random_outpoint();
        assert!(outpoint.vout < 10);
    }

    #[test]
    fn test_random_address_generation() {
        let _addr = random_address(Network::Bitcoin);
        // Address generation successful - just verify no panic
    }

    #[test]
    fn test_mock_transaction_creation() {
        let tx = create_mock_transaction(2, 3, None);
        assert_eq!(tx.input.len(), 2);
        assert_eq!(tx.output.len(), 3);
    }

    #[test]
    fn test_mock_transaction_with_amounts() {
        let amounts = vec![10_000, 20_000, 30_000];
        let tx = create_mock_transaction(1, 3, Some(amounts.clone()));
        assert_eq!(tx.output.len(), 3);
        for (i, output) in tx.output.iter().enumerate() {
            assert_eq!(output.value.to_sat(), amounts[i]);
        }
    }

    #[test]
    fn test_random_amount() {
        for _ in 0..100 {
            let amount = random_amount();
            assert!(amount >= 1_000);
            assert!(amount <= 100_000_000);
        }
    }

    #[test]
    fn test_dust_detection() {
        assert!(is_dust(0));
        assert!(is_dust(545));
        assert!(!is_dust(546));
        assert!(!is_dust(1_000));
    }

    #[test]
    fn test_p2wpkh_transaction() {
        let tx = create_p2wpkh_transaction(Network::Bitcoin);
        assert_eq!(tx.input.len(), 1);
        assert_eq!(tx.output.len(), 2);
    }
}