Advanced Testing: Fuzzing and Property-Based Testing

Advanced testing techniques are crucial for blockchain security and reliability.

Why Advanced Testing?

Blockchain code handles value - bugs can lead to:

• Financial Loss: Stolen or locked funds
• Network Disruption: Consensus failures
• Reputation Damage: Loss of trust

Traditional unit tests aren't enough. We need:

• Fuzzing: Random input testing
• Property-Based Testing: Verify invariants
• Formal Verification: Mathematical proofs
• Security Audits: Expert review

Fuzzing

Fuzzing generates random inputs to find edge cases and bugs.

Rust Fuzzing Tools

• cargo-fuzz: Official Rust fuzzing tool
• honggfuzz: Fast, efficient fuzzer
• AFL: American Fuzzy Lop

Example: Fuzzing a Hash Function

RUST
Copy
#![no_main]
use libfuzzer_sys::fuzz_target;

fuzz_target!(|data: &[u8]| {
    // Test that hash function doesn't panic
    let hash1 = hash(data);
    
    // Test determinism
    let hash2 = hash(data);
    assert_eq!(hash1, hash2);
    
    // Test collision resistance (simplified)
    if data.len() > 0 {
        let mut modified = data.to_vec();
        modified[0] ^= 1;
        let hash3 = hash(&modified);
        assert_ne!(hash1, hash3);
    }
});

Fuzzing Blockchain Components

RUST
Copy
// Fuzz transaction validation
fuzz_target!(|tx_data: TransactionData| {
    let mut blockchain = Blockchain::new();
    
    // Should never panic on any input
    let result = blockchain.validate_transaction(&tx_data);
    
    // Result should be consistent
    let result2 = blockchain.validate_transaction(&tx_data);
    assert_eq!(result, result2);
});

// Fuzz block creation
fuzz_target!(|transactions: Vec<Transaction>| {
    let mut blockchain = Blockchain::new();
    
    // Should handle any number/type of transactions
    match blockchain.create_block(transactions) {
        Ok(block) => {
            // Block should be valid
            assert!(blockchain.validate_block(&block).is_ok());
        }
        Err(_) => {
            // If creation fails, validation should also fail
        }
    }
});

Property-Based Testing

Property-based testing verifies that properties (invariants) hold for all inputs.

Using Proptest

RUST
Copy
use proptest::prelude::*;

proptest! {
    #[test]
    fn test_balance_invariant(
        transactions in prop::collection::vec(
            (0u64..1000, 0u64..1000, 0u64..100),
            0..100
        )
    ) {
        let mut balances = HashMap::new();
        let mut total = 0u64;
        
        for (from, to, amount) in transactions {
            // Property: total supply never changes
            let before_total: u64 = balances.values().sum();
            
            *balances.entry(from).or_insert(0) -= amount;
            *balances.entry(to).or_insert(0) += amount;
            
            let after_total: u64 = balances.values().sum();
            
            // Total should remain constant (no minting/burning)
            assert_eq!(before_total, after_total);
        }
    }
}

Blockchain Properties

RUST
Copy
// Property: Blockchain height always increases
proptest! {
    #[test]
    fn height_monotonic(blocks in prop::collection::vec(block_strategy(), 0..50)) {
        let mut blockchain = Blockchain::new();
        let mut last_height = 0;
        
        for block in blocks {
            if blockchain.add_block(block).is_ok() {
                let height = blockchain.height();
                assert!(height > last_height);
                last_height = height;
            }
        }
    }
}

// Property: Valid blocks are always accepted
proptest! {
    #[test]
    fn valid_blocks_accepted(block in valid_block_strategy()) {
        let mut blockchain = Blockchain::new();
        assert!(blockchain.add_block(block).is_ok());
    }
}

Security Testing

Reentrancy Testing

RUST
Copy
#[test]
fn test_reentrancy_protection() {
    let mut contract = VulnerableContract::new();
    
    // Try to reenter during withdrawal
    let attacker = Attacker::new();
    
    // Should fail or be protected
    assert!(contract.withdraw(&attacker).is_err());
}

Integer Overflow Testing

RUST
Copy
#[test]
fn test_overflow_protection() {
    let mut token = Token::new();
    
    // Try to cause overflow
    let max_amount = u64::MAX;
    
    // Should use checked arithmetic
    assert!(token.transfer("alice", "bob", max_amount).is_err());
}

Test Coverage

Measuring Coverage

BASH
Copy
# Install cargo-tarpaulin
cargo install cargo-tarpaulin

# Generate coverage report
cargo tarpaulin --out Html

Coverage Goals

• Critical Paths: 100% coverage
• Error Handling: 90%+ coverage
• Overall: 80%+ coverage

Best Practices

1. Start Early: Write tests alongside code
2. Test Edge Cases: Zero, max, negative values
3. Test Failures: Ensure errors are handled
4. Property Tests: Verify invariants
5. Fuzz Critical Code: Hash functions, validators
6. Integration Tests: Test full workflows
7. Performance Tests: Ensure scalability

Real-World Example

RUST
Copy
#[cfg(test)]
mod tests {
    use super::*;
    use proptest::prelude::*;
    
    #[test]
    fn test_basic_transfer() {
        // Unit test
    }
    
    proptest! {
        #[test]
        fn test_transfer_properties(
            amount in 0u64..1000000,
            from_balance in amount..10000000
        ) {
            // Property: transfer never creates tokens
            let mut token = Token::new();
            token.balance_of("alice") = from_balance;
            
            let total_before: u64 = token.all_balances().sum();
            token.transfer("alice", "bob", amount).unwrap();
            let total_after: u64 = token.all_balances().sum();
            
            prop_assert_eq!(total_before, total_after);
        }
    }
    
    #[test]
    #[ignore] // Run manually with: cargo test -- --ignored
    fn fuzz_transaction_validation() {
        // Fuzzing test
    }
}