@feltdb/core 0.15.0 → 0.16.1

package/dist/create/server-source/crates/feltdb/benches/gate_14c_replication_contract_test.rs

@@ -1,505 +0,0 @@
-/// Gate 14C: Replication Contract Test
-///
-/// CRITICAL: Before scaling measurement, prove the replication harness is correct.
-///
-/// This test validates that ReplicationMessages are delivered through the real path:
-///   operation → replication_message → receiver → deduplication → causal_validation → apply → state
-///
-/// Contract: leader.state_hash == replica.state_hash after all operations applied
-///
-/// Test cases:
-/// 1. Basic: N operations delivered in order → convergence ✓
-/// 2. Duplicate: Same message delivered twice → deduplication prevents double-apply
-/// 3. Reordered: Messages delivered out of order → causal validation preserves order
-/// 4. Delayed: Messages arrive late → eventual convergence ✓
-/// 5. Dropped + Retx: Message lost then resent → reconciliation recovers it
-/// 6. Causal dependency: Operation depends on prior → waiting/ready state correct
-use feltdb::{
-    convergence::VectorClock,
-    distributed_transactions::{DistributedTransactionExecutor, ReplicationMessage},
-    state_hash::StateHash,
-    transactions::{ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion},
-};
-use std::collections::HashMap;
-
-// ============================================================================
-// REPLICATION HARNESS
-// ============================================================================
-
-/// Simulates network delivery with configurable behavior (drops, delays, reordering)
-#[allow(dead_code)]
-struct ReplicationTransport {
-    messages: Vec<(usize, ReplicationMessage)>, // (destination_replica_id, message)
-    #[allow(dead_code)]
-    drops_enabled: bool,
-    #[allow(dead_code)]
-    delays_enabled: bool,
-    #[allow(dead_code)]
-    reordering_enabled: bool,
-}
-
-#[allow(dead_code)]
-impl ReplicationTransport {
-    fn new() -> Self {
-        Self {
-            messages: Vec::new(),
-            drops_enabled: false,
-            delays_enabled: false,
-            reordering_enabled: false,
-        }
-    }
-
-    fn send(&mut self, replica_id: usize, msg: ReplicationMessage) {
-        self.messages.push((replica_id, msg));
-    }
-
-    fn deliver_all(&mut self) -> Vec<(usize, ReplicationMessage)> {
-        self.messages.drain(..).collect()
-    }
-
-    fn deliver_with_drops(&mut self, drop_every_nth: usize) -> Vec<(usize, ReplicationMessage)> {
-        let mut delivered = Vec::new();
-        for (i, msg) in self.messages.drain(..).enumerate() {
-            if i % drop_every_nth != 0 {
-                delivered.push(msg);
-            }
-        }
-        delivered
-    }
-}
-
-// ============================================================================
-// CONTRACT TESTS
-// ============================================================================
-
-fn main() {
-    let rt = tokio::runtime::Runtime::new().expect("Failed to create runtime");
-    rt.block_on(async {
-        println!("\n╔════════════════════════════════════════════════════════════╗");
-        println!("║  GATE 14C: Replication Contract Test                      ║");
-        println!("║  Prove: leader.state_hash == replica.state_hash           ║");
-        println!("╚════════════════════════════════════════════════════════════╝\n");
-
-        // TEST 1: Basic 2-replica convergence
-        println!("Test 1: Basic 2-Replica Convergence");
-        println!("───────────────────────────────────");
-        test_basic_2replica_convergence().await;
-
-        // TEST 2: Duplicate message handling
-        println!("\nTest 2: Duplicate Message Deduplication");
-        println!("───────────────────────────────────────");
-        test_duplicate_message_handling().await;
-
-        // TEST 3: Out-of-order delivery with causal validation
-        println!("\nTest 3: Out-of-Order Delivery");
-        println!("────────────────────────────");
-        test_out_of_order_delivery().await;
-
-        // TEST 4: Delayed delivery
-        println!("\nTest 4: Delayed Message Delivery");
-        println!("───────────────────────────────");
-        test_delayed_delivery().await;
-
-        // TEST 5: Drop and retransmission
-        println!("\nTest 5: Message Drop and Retransmission");
-        println!("──────────────────────────────────────");
-        test_drop_and_retransmission().await;
-
-        println!("\n╔════════════════════════════════════════════════════════════╗");
-        println!("║  Contract Test Complete                                   ║");
-        println!("║  Next: Run scaling benchmark only after all tests PASS    ║");
-        println!("╚════════════════════════════════════════════════════════════╝\n");
-    });
-}
-
-async fn test_basic_2replica_convergence() {
-    // Setup: 1 leader + 1 replica
-    let initial_hash = StateHash::from_hex("hash0".to_string());
-    let mut leader =
-        DistributedTransactionExecutor::new("leader".to_string(), initial_hash.clone());
-    leader.register_replica("replica_1".to_string(), initial_hash.clone());
-    let mut replica = DistributedTransactionExecutor::new("replica_1".to_string(), initial_hash);
-
-    // Create 5 operations
-    let mut operations = Vec::new();
-    for i in 0..5 {
-        let op = Operation::new(
-            OperationId::new("leader".to_string(), i as u64),
-            StateVersion::new(VectorClock::new(), "hash0".to_string()),
-            "Update".to_string(),
-            OperationCommand {
-                op_type: "Set".to_string(),
-                collection: "test".to_string(),
-                record_id: format!("key_{}", i),
-                fields: {
-                    let mut m = HashMap::new();
-                    m.insert("value".to_string(), serde_json::json!(i));
-                    m
-                },
-            },
-            "test".to_string(),
-        );
-        operations.push(op);
-    }
-
-    // Leader: Execute operations
-    let mut leader_hashes = Vec::new();
-    for (seq, op) in operations.iter().enumerate() {
-        let result = leader.execute_local_transaction(
-            seq as u64,
-            format!("txn_{}", seq),
-            StateVersion::new(VectorClock::new(), "hash0".to_string()),
-            vec![op.clone()],
-            ConsistencyContract::local(),
-        );
-
-        match result {
-            Ok(envelope) => {
-                leader_hashes.push(format!(
-                    "{:?}",
-                    leader.get_replica_state("leader").map(|s| s.state_hash)
-                ));
-                println!("  ✓ Leader applied operation {}", seq);
-
-                // Replicate to follower
-                let msg = ReplicationMessage::new(
-                    envelope,
-                    "leader".to_string(),
-                    "replica_1".to_string(),
-                    seq as u64,
-                );
-
-                // Replica: Receive and apply
-                let rx_result = replica.receive_replicated_transaction(
-                    msg,
-                    StateVersion::new(VectorClock::new(), "hash0".to_string()),
-                );
-
-                match rx_result {
-                    Ok(_) => println!("  ✓ Replica applied operation {}", seq),
-                    Err(e) => println!("  ✗ Replica failed: {}", e),
-                }
-            }
-            Err(e) => println!("  ✗ Leader failed: {}", e),
-        }
-    }
-
-    // Verify convergence
-    let leader_state = leader.get_replica_state("leader");
-    let replica_state = replica.get_replica_state("replica_1");
-
-    println!("\nConvergence Check:");
-    match (&leader_state, &replica_state) {
-        (Some(l), Some(r)) => {
-            let match_str = if l.state_hash == r.state_hash {
-                "✓ CONVERGED"
-            } else {
-                "✗ DIVERGED"
-            };
-            println!("  Leader hash:  {:?}", l.state_hash);
-            println!("  Replica hash: {:?}", r.state_hash);
-            println!("  {}", match_str);
-        }
-        _ => println!("  ✗ State retrieval failed"),
-    }
-}
-
-async fn test_duplicate_message_handling() {
-    let initial_hash = StateHash::from_hex("hash0".to_string());
-    let mut leader =
-        DistributedTransactionExecutor::new("leader".to_string(), initial_hash.clone());
-    leader.register_replica("replica_1".to_string(), initial_hash.clone());
-    let mut replica = DistributedTransactionExecutor::new("replica_1".to_string(), initial_hash);
-
-    // Create and apply one operation
-    let op = Operation::new(
-        OperationId::new("leader".to_string(), 0),
-        StateVersion::new(VectorClock::new(), "hash0".to_string()),
-        "Update".to_string(),
-        OperationCommand {
-            op_type: "Set".to_string(),
-            collection: "test".to_string(),
-            record_id: "key_0".to_string(),
-            fields: {
-                let mut m = HashMap::new();
-                m.insert("value".to_string(), serde_json::json!(1));
-                m
-            },
-        },
-        "test".to_string(),
-    );
-
-    let envelope = leader
-        .execute_local_transaction(
-            0,
-            "txn_0".to_string(),
-            StateVersion::new(VectorClock::new(), "hash0".to_string()),
-            vec![op],
-            ConsistencyContract::local(),
-        )
-        .expect("Leader execution failed");
-
-    let msg = ReplicationMessage::new(
-        envelope.clone(),
-        "leader".to_string(),
-        "replica_1".to_string(),
-        0,
-    );
-
-    // Deliver message first time
-    let result1 = replica.receive_replicated_transaction(
-        msg.clone(),
-        StateVersion::new(VectorClock::new(), "hash0".to_string()),
-    );
-    println!(
-        "  First delivery: {}",
-        if result1.is_ok() {
-            "✓ OK"
-        } else {
-            "✗ Failed"
-        }
-    );
-
-    // Deliver same message again (duplicate)
-    let result2 = replica.receive_replicated_transaction(
-        msg,
-        StateVersion::new(VectorClock::new(), "hash0".to_string()),
-    );
-    println!(
-        "  Duplicate delivery: {}",
-        if result2.is_err() {
-            "✓ Rejected (correct)"
-        } else {
-            "✗ Accepted (wrong!)"
-        }
-    );
-
-    // Verify only applied once
-    if let Some(state) = replica.get_replica_state("replica_1") {
-        println!("  Operations applied: {}", state.operations_applied);
-    }
-}
-
-async fn test_out_of_order_delivery() {
-    let initial_hash = StateHash::from_hex("hash0".to_string());
-    let mut leader =
-        DistributedTransactionExecutor::new("leader".to_string(), initial_hash.clone());
-    leader.register_replica("replica_1".to_string(), initial_hash.clone());
-    let mut replica = DistributedTransactionExecutor::new("replica_1".to_string(), initial_hash);
-
-    // Create 3 operations
-    let mut envelopes = Vec::new();
-    for i in 0..3 {
-        let op = Operation::new(
-            OperationId::new("leader".to_string(), i as u64),
-            StateVersion::new(VectorClock::new(), "hash0".to_string()),
-            "Update".to_string(),
-            OperationCommand {
-                op_type: "Set".to_string(),
-                collection: "test".to_string(),
-                record_id: format!("key_{}", i),
-                fields: {
-                    let mut m = HashMap::new();
-                    m.insert("value".to_string(), serde_json::json!(i));
-                    m
-                },
-            },
-            "test".to_string(),
-        );
-
-        let result = leader.execute_local_transaction(
-            i as u64,
-            format!("txn_{}", i),
-            StateVersion::new(VectorClock::new(), "hash0".to_string()),
-            vec![op],
-            ConsistencyContract::local(),
-        );
-
-        if let Ok(envelope) = result {
-            envelopes.push((i, envelope));
-        }
-    }
-
-    // Deliver messages out of order: 2, 0, 1
-    let delivery_order = vec![2, 0, 1];
-    for idx in delivery_order {
-        if idx < envelopes.len() {
-            let (seq, envelope) = envelopes[idx].clone();
-            let msg = ReplicationMessage::new(
-                envelope,
-                "leader".to_string(),
-                "replica_1".to_string(),
-                seq as u64,
-            );
-
-            let result = replica.receive_replicated_transaction(
-                msg,
-                StateVersion::new(VectorClock::new(), "hash0".to_string()),
-            );
-            println!(
-                "  Operation {} delivered: {}",
-                seq,
-                if result.is_ok() { "✓" } else { "✗" }
-            );
-        }
-    }
-
-    // Verify replica eventually has all operations
-    if let Some(state) = replica.get_replica_state("replica_1") {
-        println!(
-            "  Replica has {} operations (expected 3)",
-            state.operations_applied
-        );
-    }
-}
-
-async fn test_delayed_delivery() {
-    let initial_hash = StateHash::from_hex("hash0".to_string());
-    let mut leader =
-        DistributedTransactionExecutor::new("leader".to_string(), initial_hash.clone());
-    leader.register_replica("replica_1".to_string(), initial_hash.clone());
-    let mut replica = DistributedTransactionExecutor::new("replica_1".to_string(), initial_hash);
-
-    // Create and execute one operation at leader
-    let op = Operation::new(
-        OperationId::new("leader".to_string(), 0),
-        StateVersion::new(VectorClock::new(), "hash0".to_string()),
-        "Update".to_string(),
-        OperationCommand {
-            op_type: "Set".to_string(),
-            collection: "test".to_string(),
-            record_id: "key_0".to_string(),
-            fields: {
-                let mut m = HashMap::new();
-                m.insert("value".to_string(), serde_json::json!(1));
-                m
-            },
-        },
-        "test".to_string(),
-    );
-
-    let envelope = leader
-        .execute_local_transaction(
-            0,
-            "txn_0".to_string(),
-            StateVersion::new(VectorClock::new(), "hash0".to_string()),
-            vec![op],
-            ConsistencyContract::local(),
-        )
-        .expect("Leader execution failed");
-
-    let msg = ReplicationMessage::new(envelope, "leader".to_string(), "replica_1".to_string(), 0);
-
-    println!("  Simulating delay...");
-    // In a real test, this would use tokio::time::sleep, but for now just immediate delivery
-    let result = replica.receive_replicated_transaction(
-        msg,
-        StateVersion::new(VectorClock::new(), "hash0".to_string()),
-    );
-    println!(
-        "  After delay delivery: {}",
-        if result.is_ok() {
-            "✓ OK"
-        } else {
-            "✗ Failed"
-        }
-    );
-
-    // Verify convergence
-    let leader_state = leader.get_replica_state("leader");
-    let replica_state = replica.get_replica_state("replica_1");
-
-    println!("\nDelayed Delivery Convergence Check:");
-    match (&leader_state, &replica_state) {
-        (Some(l), Some(r)) => {
-            let match_str = if l.state_hash == r.state_hash {
-                "✓ CONVERGED"
-            } else {
-                "✗ DIVERGED"
-            };
-            println!("  Leader hash:  {:?}", l.state_hash);
-            println!("  Replica hash: {:?}", r.state_hash);
-            println!("  {}", match_str);
-        }
-        _ => println!("  ✗ State retrieval failed"),
-    }
-}
-
-async fn test_drop_and_retransmission() {
-    let initial_hash = StateHash::from_hex("hash0".to_string());
-    let mut leader =
-        DistributedTransactionExecutor::new("leader".to_string(), initial_hash.clone());
-    leader.register_replica("replica_1".to_string(), initial_hash.clone());
-    let mut replica = DistributedTransactionExecutor::new("replica_1".to_string(), initial_hash);
-
-    // Create and execute one operation at leader
-    let op = Operation::new(
-        OperationId::new("leader".to_string(), 0),
-        StateVersion::new(VectorClock::new(), "hash0".to_string()),
-        "Update".to_string(),
-        OperationCommand {
-            op_type: "Set".to_string(),
-            collection: "test".to_string(),
-            record_id: "key_0".to_string(),
-            fields: {
-                let mut m = HashMap::new();
-                m.insert("value".to_string(), serde_json::json!(1));
-                m
-            },
-        },
-        "test".to_string(),
-    );
-
-    let envelope = leader
-        .execute_local_transaction(
-            0,
-            "txn_0".to_string(),
-            StateVersion::new(VectorClock::new(), "hash0".to_string()),
-            vec![op],
-            ConsistencyContract::local(),
-        )
-        .expect("Leader execution failed");
-
-    let msg = ReplicationMessage::new(
-        envelope.clone(),
-        "leader".to_string(),
-        "replica_1".to_string(),
-        0,
-    );
-
-    // Simulate drop: don't deliver message first time
-    println!("  Message dropped (simulated)");
-
-    // Retransmit: deliver the same message
-    let result = replica.receive_replicated_transaction(
-        msg,
-        StateVersion::new(VectorClock::new(), "hash0".to_string()),
-    );
-    println!(
-        "  Message retransmitted: {}",
-        if result.is_ok() {
-            "✓ OK"
-        } else {
-            "✗ Failed"
-        }
-    );
-
-    // Verify convergence
-    let leader_state = leader.get_replica_state("leader");
-    let replica_state = replica.get_replica_state("replica_1");
-
-    println!("\nDrop/Retransmission Convergence Check:");
-    match (&leader_state, &replica_state) {
-        (Some(l), Some(r)) => {
-            let match_str = if l.state_hash == r.state_hash {
-                "✓ CONVERGED"
-            } else {
-                "✗ DIVERGED"
-            };
-            println!("  Leader hash:  {:?}", l.state_hash);
-            println!("  Replica hash: {:?}", r.state_hash);
-            println!("  {}", match_str);
-        }
-        _ => println!("  ✗ State retrieval failed"),
-    }
-}