thermogram 0.2.0

//! Adversarial tests - intentional attacks, corruption, edge cases
//!
//! These tests verify Thermogram's security properties:
//! - Tamper detection
//! - Corruption recovery
//! - Invalid input rejection
//! - Resource exhaustion protection

use thermogram::*;
use tempfile::tempdir;

#[test]
fn test_detect_hash_tampering() {
    let mut thermo = Thermogram::new("test", PlasticityRule::stdp_like());

    // Create valid delta
    let delta = Delta::create("key1", b"value1".to_vec(), "source");
    thermo.apply_delta(delta.clone()).unwrap();

    // Tamper with hash chain
    let mut tampered = thermo.clone();
    tampered.dirty_chain.deltas[0].hash = "tampered_hash".to_string();

    // Verify should fail
    assert!(tampered.dirty_chain.verify().is_err());
}

#[test]
fn test_reject_invalid_chain_link() {
    let mut thermo = Thermogram::new("test", PlasticityRule::stdp_like());

    let delta1 = Delta::create("key1", b"value1".to_vec(), "source");
    thermo.apply_delta(delta1).unwrap();

    // Try to append with wrong prev_hash
    let delta2 = Delta::update(
        "key1",
        b"value2".to_vec(),
        "source",
        0.8,
        Some("wrong_hash".to_string()),
    );

    // Should reject
    assert!(thermo.apply_delta(delta2).is_err());
}

#[test]
fn test_corrupted_file_load() {
    let dir = tempdir().unwrap();
    let path = dir.path().join("corrupted.thermo");

    // Write invalid JSON
    std::fs::write(&path, b"{ invalid json !!!").unwrap();

    // Should fail gracefully
    let result = Thermogram::load(&path);
    assert!(result.is_err());
}

#[test]
fn test_partial_file_corruption() {
    let dir = tempdir().unwrap();
    let path = dir.path().join("partial.thermo");

    // Create valid Thermogram
    let mut thermo = Thermogram::new("test", PlasticityRule::stdp_like());
    let delta = Delta::create("key1", b"value1".to_vec(), "source");
    thermo.apply_delta(delta).unwrap();
    thermo.save(&path).unwrap();

    // Corrupt the file (truncate last 100 bytes)
    let data = std::fs::read(&path).unwrap();
    let truncated = &data[..data.len().saturating_sub(100)];
    std::fs::write(&path, truncated).unwrap();

    // Should detect corruption
    let result = Thermogram::load(&path);
    assert!(result.is_err());
}

#[test]
fn test_neuromod_bounds_violation() {
    let mut state = NeuromodState::baseline();

    // Try to push beyond bounds
    state.reward(10.0); // Huge reward

    // Should clamp to [0, 1]
    assert!(state.dopamine >= 0.0 && state.dopamine <= 1.0);
}

#[test]
fn test_negative_neuromod_values() {
    let mut state = NeuromodState::baseline();

    state.stress(10.0); // Extreme stress

    // All values should remain in [0, 1]
    assert!(state.serotonin >= 0.0 && state.serotonin <= 1.0);
    assert!(state.norepinephrine >= 0.0 && state.norepinephrine <= 1.0);
}

#[test]
fn test_empty_key_rejection() {
    let delta = Delta::create("", b"value".to_vec(), "source");

    // Empty keys should be rejected (implementation needed)
    // For now, just verify it doesn't panic
    assert!(!delta.key.is_empty() || delta.key.is_empty());
}

#[test]
fn test_huge_value_delta() {
    let mut thermo = Thermogram::new("test", PlasticityRule::stdp_like());

    // 10 MB value
    let huge_value = vec![0u8; 10_000_000];
    let delta = Delta::create("huge", huge_value, "source");

    // Should handle gracefully (may be slow but shouldn't crash)
    let result = thermo.apply_delta(delta);
    assert!(result.is_ok() || result.is_err()); // Either works or rejects
}

#[test]
fn test_consolidation_with_all_weak_entries() {
    let mut thermo = Thermogram::new("test", PlasticityRule::stdp_like());

    // Add entries with very weak strength
    for i in 0..10 {
        let delta = Delta::update(
            format!("weak_{}", i),
            b"value".to_vec(),
            "source",
            0.01, // Below prune threshold
            thermo.dirty_chain.head_hash.clone(),
        );
        thermo.apply_delta(delta).unwrap();
    }

    // Consolidate - should prune all
    let result = thermo.consolidate().unwrap();

    assert_eq!(result.entries_pruned, 10);
    assert_eq!(thermo.clean_state.len(), 0);
}

#[test]
fn test_hash_collision_resistance() {
    // Two different deltas should have different hashes
    let delta1 = Delta::create("key1", b"value1".to_vec(), "source");
    let delta2 = Delta::create("key2", b"value2".to_vec(), "source");

    assert_ne!(delta1.hash, delta2.hash);
}

#[test]
fn test_replay_attack_prevention() {
    let mut thermo = Thermogram::new("test", PlasticityRule::stdp_like());

    let delta = Delta::create("key1", b"value1".to_vec(), "source");
    thermo.apply_delta(delta.clone()).unwrap();

    // Try to replay the same delta
    let result = thermo.apply_delta(delta);

    // Should reject (prev_hash doesn't match current head)
    assert!(result.is_err());
}

#[test]
fn test_concurrent_write_detection() {
    // This would require threading, but we can simulate
    let mut thermo = Thermogram::new("test", PlasticityRule::stdp_like());

    let delta1 = Delta::create("key1", b"value1".to_vec(), "source");
    let head1 = delta1.hash.clone();
    thermo.apply_delta(delta1).unwrap();

    // Simulate concurrent write with stale head
    let delta2 = Delta::update("key1", b"value2".to_vec(), "source", 0.8, Some(head1));

    // This should work (sequential)
    // In real concurrent scenario, one would fail
    assert!(thermo.apply_delta(delta2).is_ok());
}

#[test]
fn test_snn_nan_protection() {
    let config = EmbeddedSNNConfig::default();
    let mut snn = EmbeddedSNN::new(config);

    // Feed NaN input
    let input = vec![f32::NAN; 2048];
    let neuromod = NeuromodState::baseline();

    let result = snn.process(&input, &neuromod);

    // Should either handle gracefully or error (not panic)
    match result {
        Ok(deltas) => {
            // Verify deltas don't contain NaN
            for delta in deltas {
                // Check serialized value doesn't have NaN
                assert!(!delta.value.is_empty());
            }
        }
        Err(_) => {
            // Rejecting NaN is acceptable
        }
    }
}

#[test]
fn test_snn_infinity_protection() {
    let config = EmbeddedSNNConfig::default();
    let mut snn = EmbeddedSNN::new(config);

    // Feed infinite input
    let input = vec![f32::INFINITY; 2048];
    let neuromod = NeuromodState::baseline();

    let result = snn.process(&input, &neuromod);

    // Should handle gracefully
    assert!(result.is_ok() || result.is_err());
}

#[test]
fn test_memory_bomb_protection() {
    let mut thermo = Thermogram::new("test", PlasticityRule::stdp_like());

    // Try to create millions of deltas
    // (In production, should have rate limiting)
    for i in 0..1000 {
        let delta = Delta::create(
            format!("key_{}", i),
            b"value".to_vec(),
            "source",
        );

        if let Err(_) = thermo.apply_delta(delta) {
            // Acceptable to reject after some point
            break;
        }
    }

    // Should still be functional
    assert!(thermo.read("key_0").is_ok());
}