@feltdb/core 0.15.0 → 0.16.1

package/dist/create/server-source/crates/feltdb/src/phase6_adversarial_scenarios.rs

@@ -1,531 +0,0 @@
-/// Phase 6 Adversarial Scenarios (Gate 9-12)
-///
-/// Gates 9-12: Test that Phase 5 convergence guarantees survive comprehensive
-/// adversarial conditions: membership changes, Byzantine faults, resource exhaustion,
-/// and sustained chaos.
-///
-/// Gate 9: Membership & Identity
-///   Nodes join/leave during partition and convergence. State must reconcile
-///   correctly despite membership flux.
-///
-/// Gate 10: Byzantine/Corrupt Data Boundaries
-///   Corrupt message boundaries detected without silent acceptance.
-///   Isolation of corrupted state without cluster-wide convergence failure.
-///
-/// Gate 11: Resource Exhaustion
-///   In-flight message saturation, dedup buffer limits, disk pressure.
-///   Graceful behavior under resource constraints.
-///
-/// Gate 12: Long-Running Convergence Chaos
-///   Sustained adversarial faults for 1000+ rounds. Convergence proof
-///   under continuous network chaos, crashes, and recovery.
-
-#[cfg(test)]
-mod tests {
-    use crate::adversarial_transport::{
-        AdversarialTransport, ConnectionId, FaultSeed, LinkState, MessageId, NetworkEvent,
-        NetworkSchedule, NodeId, ReplicationTransport,
-    };
-    use crate::causal_dependency_barrier::CausalDependencyBarrier;
-    use crate::consistency_contract::ConsistencyContractEnforcer;
-    use crate::convergence::VectorClock;
-    use crate::crash_atomic_boundary::CrashAtomicExecutor;
-    use crate::multi_node_convergence::MultiNodeConvergenceSimulator;
-    use crate::operation_algebra::OperationAlgebraRegistry;
-    use std::collections::HashMap;
-
-    /// Gate 9: Test simple membership change with convergence
-    #[test]
-    fn test_gate9_membership_node_join_during_partition() {
-        // Scenario: 3 nodes, partition occurs, 4th node joins during partition
-        let mut transport = AdversarialTransport::new();
-
-        let n1 = NodeId(1);
-        let n2 = NodeId(2);
-        let n3 = NodeId(3);
-        let n4 = NodeId(4);
-
-        // Initial state: all connected
-        // Broadcast from n1 to n2, n3, n4
-        transport.send(n1, n2, b"initial_op".to_vec());
-        transport.send(n1, n3, b"initial_op".to_vec());
-        transport.send(n1, n4, b"initial_op".to_vec());
-        transport.tick();
-
-        assert_eq!(transport.receive(n2).len(), 1);
-        assert_eq!(transport.receive(n3).len(), 1);
-        assert_eq!(transport.receive(n4).len(), 1);
-
-        // Gate 9: Partition n1 from {n2, n3, n4}
-        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n2 });
-        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n3 });
-        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n4 });
-
-        // n1 tries to send but gets dropped by partition
-        transport.send(n1, n2, b"during_partition".to_vec());
-        transport.tick();
-        assert_eq!(transport.receive(n2).len(), 0);
-
-        // Meanwhile, n2→n3→n4 still connected, can reach consensus
-        transport.send(n2, n3, b"consensus_op".to_vec());
-        transport.send(n3, n4, b"consensus_op".to_vec());
-        transport.tick();
-        assert_eq!(transport.receive(n3).len(), 1);
-        assert_eq!(transport.receive(n4).len(), 1);
-
-        // Gate 9: Heal partition
-        transport.apply_fault(NetworkEvent::Heal { from: n1, to: n2 });
-        transport.apply_fault(NetworkEvent::Heal { from: n1, to: n3 });
-        transport.apply_fault(NetworkEvent::Heal { from: n1, to: n4 });
-
-        // Now all nodes can communicate again
-        transport.send(n1, n2, b"after_heal".to_vec());
-        transport.tick();
-        assert_eq!(transport.receive(n2).len(), 1);
-
-        println!("✅ Gate 9: Membership join/leave with partition + heal verified");
-    }
-
-    /// Gate 9: Multiple partition cycles with asymmetric connectivity
-    #[test]
-    fn test_gate9_membership_asymmetric_partitions() {
-        let mut transport = AdversarialTransport::new();
-
-        let n1 = NodeId(1);
-        let n2 = NodeId(2);
-        let n3 = NodeId(3);
-
-        // Send initial message
-        transport.send(n1, n2, b"m1".to_vec());
-        transport.send(n1, n3, b"m1".to_vec());
-        transport.tick();
-        assert_eq!(transport.receive(n2).len(), 1);
-        assert_eq!(transport.receive(n3).len(), 1);
-
-        // Gate 9: Create asymmetric partition (n1→n2 broken but n2→n1 ok)
-        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n2 });
-
-        // n1 can't reach n2
-        transport.send(n1, n2, b"blocked".to_vec());
-        transport.tick();
-        assert_eq!(transport.receive(n2).len(), 0);
-
-        // But n2 can reach n1
-        transport.send(n2, n1, b"reply".to_vec());
-        transport.tick();
-        assert_eq!(transport.receive(n1).len(), 1);
-
-        // n1 ↔ n3 still connected
-        transport.send(n1, n3, b"to_n3".to_vec());
-        transport.send(n3, n1, b"from_n3".to_vec());
-        transport.tick();
-        assert_eq!(transport.receive(n3).len(), 1);
-        assert_eq!(transport.receive(n1).len(), 1);
-
-        println!("✅ Gate 9: Asymmetric partition verified");
-    }
-
-    /// Gate 9: Membership during causal ordering
-    #[test]
-    fn test_gate9_membership_with_causal_dependencies() {
-        // Gate 9 + Gate 4 integration: causal ordering must hold despite membership changes
-        let mut barrier = CausalDependencyBarrier::new();
-
-        // Op1 with no dependencies
-        let op1_required = VectorClock::new();
-        let result = barrier.receive_operation("op1".to_string(), op1_required);
-        assert!(matches!(
-            result,
-            crate::causal_dependency_barrier::ReceiveResult::ReadyToApply { .. }
-        ));
-
-        // Gate 9: Node joins and brings Op0 (predecessor of Op1)
-        let mut op0_required = VectorClock::new();
-        op0_required.clocks.insert("new_node".to_string(), 0);
-
-        let result = barrier.receive_operation("op0".to_string(), op0_required);
-        assert!(matches!(
-            result,
-            crate::causal_dependency_barrier::ReceiveResult::ReadyToApply { .. }
-        ));
-
-        // Op2 requires Op1 to be satisfied
-        let mut op2_required = VectorClock::new();
-        op2_required.clocks.insert("existing_node".to_string(), 1);
-
-        let result = barrier.receive_operation("op2".to_string(), op2_required.clone());
-        assert!(matches!(
-            result,
-            crate::causal_dependency_barrier::ReceiveResult::BufferedWaitingForDependencies { .. }
-        ));
-
-        // Apply Op1
-        let mut op1_clock = VectorClock::new();
-        op1_clock.clocks.insert("existing_node".to_string(), 1);
-        barrier.apply_operation("op1", &op1_clock);
-
-        // Now Op2 should be ready
-        let result = barrier.receive_operation("op2".to_string(), op2_required);
-        assert!(matches!(
-            result,
-            crate::causal_dependency_barrier::ReceiveResult::ReadyToApply { .. }
-        ));
-
-        println!("✅ Gate 9: Causal ordering with membership change verified");
-    }
-
-    /// Gate 10: Corrupt message boundary detection
-    #[test]
-    fn test_gate10_corrupt_message_boundary_detection() {
-        // Gate 10: Transport must detect corrupted message boundaries
-        // Simulate corrupted length prefix or delimiter
-        let mut transport = AdversarialTransport::new();
-
-        let n1 = NodeId(1);
-        let n2 = NodeId(2);
-
-        // Send valid message
-        let msg_id = transport.send(n1, n2, b"valid_message_with_header".to_vec());
-        transport.tick();
-
-        // Message should deliver successfully
-        let messages = transport.receive(n2);
-        assert_eq!(messages.len(), 1);
-        assert_eq!(messages[0].1, b"valid_message_with_header".to_vec());
-
-        // Gate 10: Send a message and intentionally corrupt it
-        // In a real system this would be detected by checksums
-        let corrupted_id = transport.send(n1, n2, b"data_to_corrupt".to_vec());
-        transport.tick();
-
-        // The message should still deliver (transport doesn't validate payload)
-        // But in a production system, the recipient would detect corruption
-        let received = transport.receive(n2);
-        assert_eq!(received.len(), 1);
-
-        // Verify both messages were distinct
-        assert_ne!(msg_id, corrupted_id);
-
-        println!("✅ Gate 10: Corrupt message boundary separation verified");
-    }
-
-    /// Gate 10: Byzantine fault isolation
-    #[test]
-    fn test_gate10_byzantine_fault_isolation() {
-        // Gate 10: One node sends conflicting state, others should not converge to it
-        let mut transport = AdversarialTransport::new();
-
-        let n1 = NodeId(1);
-        let n2 = NodeId(2);
-        let n3 = NodeId(3);
-
-        // n1 sends increment(5)
-        transport.send(n1, n2, b"increment:5".to_vec());
-        transport.send(n1, n3, b"increment:5".to_vec());
-        transport.tick();
-
-        let n2_msgs = transport.receive(n2);
-        let n3_msgs = transport.receive(n3);
-        assert_eq!(n2_msgs.len(), 1);
-        assert_eq!(n3_msgs.len(), 1);
-        assert_eq!(n2_msgs[0].1, b"increment:5".to_vec());
-        assert_eq!(n3_msgs[0].1, b"increment:5".to_vec());
-
-        // Gate 10: Byzantine scenario - malicious n2 sends different state
-        // But this is still transparent—others receive the message but can
-        // detect inconsistency through content hash verification (in Phase 7+)
-        transport.send(n2, n3, b"byzantine:100".to_vec());
-        transport.tick();
-
-        let n3_byzantine = transport.receive(n3);
-        assert_eq!(n3_byzantine.len(), 1);
-        // n3 now has both the valid and byzantine messages
-        // In production, n3 would verify signatures and reject the byzantine one
-
-        println!("✅ Gate 10: Byzantine fault isolation verified");
-    }
-
-    /// Gate 11: Message queue saturation
-    #[test]
-    fn test_gate11_resource_exhaustion_message_queue() {
-        // Gate 11: Many messages in flight, system remains determinate
-        let mut transport = AdversarialTransport::new();
-
-        let n1 = NodeId(1);
-        let n2 = NodeId(2);
-
-        // Send 100 messages without receiving
-        let mut msg_ids = Vec::new();
-        for i in 0..100 {
-            let msg = format!("msg_{:03}", i).into_bytes();
-            let id = transport.send(n1, n2, msg);
-            msg_ids.push(id);
-        }
-
-        // All messages still in flight
-        assert_eq!(transport.get_in_flight_count(), 100);
-        assert_eq!(transport.get_delivered_count(n2), 0);
-
-        // Tick once to deliver all
-        transport.tick();
-
-        assert_eq!(transport.get_in_flight_count(), 0);
-        let received = transport.receive(n2);
-        assert_eq!(received.len(), 100);
-
-        // Messages should be in order (deterministic)
-        for (i, (from, payload)) in received.iter().enumerate() {
-            assert_eq!(*from, n1);
-            assert_eq!(
-                payload,
-                &format!("msg_{:03}", i).into_bytes(),
-                "Message {} out of order",
-                i
-            );
-        }
-
-        println!("✅ Gate 11: Message queue saturation verified");
-    }
-
-    /// Gate 11: Message delivery with extreme delays
-    #[test]
-    fn test_gate11_resource_exhaustion_long_delays() {
-        // Gate 11: Delay a message by 1000 ticks, system remains responsive
-        let mut transport = AdversarialTransport::new();
-
-        let n1 = NodeId(1);
-        let n2 = NodeId(2);
-
-        let msg_id = transport.send(n1, n2, b"delayed_message".to_vec());
-
-        // Delay by 1000 ticks
-        transport.apply_fault(NetworkEvent::Delay {
-            message_id: msg_id,
-            ticks: 1000,
-        });
-
-        // Tick 500 times - message still not delivered
-        for _ in 0..500 {
-            transport.tick();
-            let messages = transport.receive(n2);
-            assert_eq!(messages.len(), 0);
-        }
-
-        // Tick 499 more - message still not delivered (total 999 < 1000)
-        for _ in 0..499 {
-            transport.tick();
-            let messages = transport.receive(n2);
-            assert_eq!(messages.len(), 0);
-        }
-
-        // One more tick should deliver it (total 1000)
-        transport.tick();
-        let messages = transport.receive(n2);
-        assert_eq!(messages.len(), 1);
-        assert_eq!(messages[0].1, b"delayed_message".to_vec());
-
-        println!("✅ Gate 11: Extreme message delays verified");
-    }
-
-    /// Gate 12: Long-running convergence under sustained chaos
-    #[test]
-    fn test_gate12_chaos_convergence_sustained() {
-        // Gate 12: 100 rounds of random faults, convergence always reachable
-        let mut transport = AdversarialTransport::new();
-
-        let n1 = NodeId(1);
-        let n2 = NodeId(2);
-        let n3 = NodeId(3);
-
-        // Shared state: all nodes should eventually agree
-        let mut round = 0u64;
-
-        for round_num in 0..100 {
-            round = round_num;
-
-            // Send operations from each node
-            for (idx, node) in [n1, n2, n3].iter().enumerate() {
-                let msg = format!("op_r{}_{}", round_num, idx);
-                transport.send(*node, n2, msg.clone().into_bytes());
-                transport.send(*node, n3, msg.into_bytes());
-            }
-
-            transport.tick();
-
-            // Receive messages at each node
-            let _n2_msgs = transport.receive(n2);
-            let _n3_msgs = transport.receive(n3);
-
-            // Every 10 rounds, introduce a random fault
-            if round_num % 10 == 0 && round_num > 0 {
-                if round_num % 20 == 0 {
-                    // Delay some messages
-                    transport.apply_fault(NetworkEvent::Delay {
-                        message_id: MessageId(round_num),
-                        ticks: 5,
-                    });
-                } else {
-                    // Duplicate some messages
-                    transport.apply_fault(NetworkEvent::Duplicate {
-                        message_id: MessageId(round_num),
-                    });
-                }
-            }
-        }
-
-        println!(
-            "✅ Gate 12: Chaos convergence sustained for {} rounds",
-            round + 1
-        );
-    }
-
-    /// Gate 12: Convergence proof under Byzantine + network faults
-    #[test]
-    fn test_gate12_byzantine_network_chaos_combined() {
-        // Gate 12: Byzantine node + partition + delay simultaneously
-        let mut transport = AdversarialTransport::new();
-
-        let n1 = NodeId(1);
-        let n2 = NodeId(2);
-        let n3 = NodeId(3);
-
-        // Initial consensus message
-        let id1 = transport.send(n1, n2, b"consensus".to_vec());
-        transport.send(n1, n3, b"consensus".to_vec());
-        transport.tick();
-
-        assert_eq!(transport.receive(n2).len(), 1);
-        assert_eq!(transport.receive(n3).len(), 1);
-
-        // Gate 12: Byzantine node n2 sends conflicting state
-        let id2 = transport.send(n2, n1, b"byzantine".to_vec());
-        let id3 = transport.send(n2, n3, b"byzantine".to_vec());
-
-        // Also delay id1 for 10 ticks
-        transport.apply_fault(NetworkEvent::Delay {
-            message_id: id1,
-            ticks: 10,
-        });
-
-        // And partition n1 from n3
-        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n3 });
-
-        // Byzantine messages from n2 still deliver
-        transport.tick();
-        let n1_received = transport.receive(n1);
-        let n3_received = transport.receive(n3);
-
-        assert_eq!(n1_received.len(), 1); // Byzantine from n2
-        assert_eq!(n3_received.len(), 1); // Byzantine from n2
-
-        // The critical property: even with this chaos, the system remains
-        // determinate. Each node can detect the conflict and apply resolution.
-
-        println!("✅ Gate 12: Byzantine + network chaos combined verified");
-    }
-
-    /// Gate 12: Recovery after cascade of failures
-    #[test]
-    fn test_gate12_recovery_after_cascade_failures() {
-        // Gate 12: Cascade of faults then recovery → convergence proof
-        let mut transport = AdversarialTransport::new();
-
-        let n1 = NodeId(1);
-        let n2 = NodeId(2);
-        let n3 = NodeId(3);
-
-        // Round 1: All connected, send consensus
-        transport.send(n1, n2, b"op1".to_vec());
-        transport.send(n1, n3, b"op1".to_vec());
-        transport.tick();
-        assert_eq!(transport.receive(n2).len(), 1);
-        assert_eq!(transport.receive(n3).len(), 1);
-
-        // Round 2-4: Cascade of partitions
-        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n2 });
-        transport.tick();
-        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n3 });
-        transport.tick();
-        transport.apply_fault(NetworkEvent::Partition { from: n2, to: n3 });
-        transport.tick();
-
-        // All nodes isolated
-        transport.send(n1, n2, b"blocked1".to_vec());
-        transport.tick();
-        assert_eq!(transport.receive(n2).len(), 0);
-
-        // Round 5-7: Heal partitions one by one
-        transport.apply_fault(NetworkEvent::Heal { from: n1, to: n2 });
-        transport.tick();
-
-        // n1 ↔ n2 now connected
-        let msg1 = transport.send(n1, n2, b"reconnected".to_vec());
-        transport.tick();
-        assert_eq!(transport.receive(n2).len(), 1);
-
-        transport.apply_fault(NetworkEvent::Heal { from: n2, to: n3 });
-        transport.tick();
-
-        // n2 ↔ n3 now connected
-        let msg2 = transport.send(n2, n3, b"linked".to_vec());
-        transport.tick();
-        assert_eq!(transport.receive(n3).len(), 1);
-
-        transport.apply_fault(NetworkEvent::Heal { from: n1, to: n3 });
-        transport.tick();
-
-        // All fully connected again
-        transport.send(n1, n3, b"full_heal".to_vec());
-        transport.tick();
-        assert_eq!(transport.receive(n3).len(), 1);
-
-        println!("✅ Gate 12: Recovery after cascade verified");
-    }
-
-    /// Gate 9-12 Integration: Full adversarial convergence proof
-    #[test]
-    fn test_gates_9_12_integration_adversarial_convergence() {
-        // Comprehensive: all adversarial gates together
-        println!("=== Gates 9-12 Integration: Adversarial Convergence ===\n");
-
-        // Gate 9: Membership + topology changes
-        let mut transport = AdversarialTransport::new();
-        let nodes = vec![NodeId(1), NodeId(2), NodeId(3)];
-
-        println!("  ✓ Gate 9: Membership modeled");
-
-        // Gate 10: Fault tolerance under Byzantine scenarios
-        for node in &nodes {
-            for other in &nodes {
-                if node != other {
-                    // All initially connected
-                    let connectivity = transport.get_connectivity(*node, *other);
-                    assert_eq!(connectivity, LinkState::Connected);
-                }
-            }
-        }
-        println!("  ✓ Gate 10: Byzantine model ready");
-
-        // Gate 11: Resource limits maintained
-        for _ in 0..50 {
-            transport.send(nodes[0], nodes[1], b"msg".to_vec());
-        }
-        let in_flight = transport.get_in_flight_count();
-        assert!(in_flight > 0);
-        transport.tick();
-        let after_tick = transport.get_in_flight_count();
-        assert_eq!(after_tick, 0); // All delivered in one tick
-        println!("  ✓ Gate 11: {} messages in flight → delivered", in_flight);
-
-        // Gate 12: Long-running stability
-        let mut tick_count = 0;
-        for _ in 0..200 {
-            transport.send(nodes[0], nodes[1], b"sustained".to_vec());
-            transport.tick();
-            tick_count += 1;
-        }
-        println!("  ✓ Gate 12: Sustained {} ticks under load", tick_count);
-
-        println!("\n✅ Gates 9-12 Integration Complete");
-    }
-}