@feltdb/core 0.15.0 → 0.16.1

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

@@ -1,203 +0,0 @@
-/// Track 1c.1 Acceptance Tests
-///
-/// Objective: Prove durable operation persistence in the real DistributedTransactionExecutor
-///
-/// These tests validate that:
-/// 1. Operations are durably persisted to disk with fsync
-/// 2. Process restart recovers persisted operations
-/// 3. Dedup set is rebuilt from persisted log on startup
-/// 4. Normal replication continues after recovery
-
-#[cfg(test)]
-mod tests {
-    use crate::distributed_transactions::TransactionEnvelope;
-    use crate::durable_operation_log::OperationLog;
-    use crate::state_hash::StateHash;
-    use crate::transactions::{ConsistencyContract, ConsistencyLevel};
-    use tempfile::TempDir;
-
-    fn create_test_envelope(node: &str, sequence: u64) -> TransactionEnvelope {
-        TransactionEnvelope::new(
-            node.to_string(),
-            sequence,
-            format!("tx{}", sequence),
-            Vec::new(),
-            ConsistencyContract {
-                level: ConsistencyLevel::Causal,
-                timeout_ms: Some(1000),
-                required_acks: None,
-            },
-        )
-    }
-
-    /// TC-1c.1-001: Durable operation log persists and recovers single envelope
-    ///
-    /// This test validates the operation log durability layer directly:
-    /// 1. Create log and persist an envelope
-    /// 2. Create new log instance from same path
-    /// 3. Verify envelope is recovered
-    #[test]
-    fn test_durable_log_survives_restart() -> Result<(), Box<dyn std::error::Error>> {
-        let temp_dir = TempDir::new()?;
-        let log_path = temp_dir.path().join("operations.log");
-
-        // Step 1: Create log and persist envelope
-        {
-            let mut log = OperationLog::new(&log_path)?;
-            let envelope = create_test_envelope("nodeA", 1);
-            log.append(&envelope)?;
-        }
-
-        // Step 2 & 3: Create new log from same path and verify recovery
-        {
-            let log = OperationLog::new(&log_path)?;
-            let loaded = log.load_all()?;
-
-            assert_eq!(loaded.len(), 1, "Should have persisted 1 envelope");
-            assert_eq!(loaded[0].envelope_id.sequence, 1);
-            assert_eq!(loaded[0].transaction_id, "tx1");
-        }
-
-        Ok(())
-    }
-
-    /// TC-1c.1-002: Multiple envelopes persist and recover in order
-    ///
-    /// Sequence:
-    /// 1. Persist 3 envelopes to log
-    /// 2. Recover log from disk
-    /// 3. Verify all 3 recovered in order
-    #[test]
-    fn test_durable_log_multiple_envelopes_in_order() -> Result<(), Box<dyn std::error::Error>> {
-        let temp_dir = TempDir::new()?;
-        let log_path = temp_dir.path().join("operations.log");
-
-        // Step 1: Persist 3 envelopes
-        {
-            let mut log = OperationLog::new(&log_path)?;
-            for seq in 1..=3 {
-                let envelope = create_test_envelope("nodeA", seq);
-                log.append(&envelope)?;
-            }
-        }
-
-        // Step 2 & 3: Recover and verify
-        {
-            let log = OperationLog::new(&log_path)?;
-            let loaded = log.load_all()?;
-
-            assert_eq!(loaded.len(), 3, "Should have recovered 3 envelopes");
-            for (i, envelope) in loaded.iter().enumerate() {
-                assert_eq!(
-                    envelope.envelope_id.sequence,
-                    (i + 1) as u64,
-                    "Envelopes should be in order"
-                );
-            }
-        }
-
-        Ok(())
-    }
-
-    /// TC-1c.1-003: Durable log fsync ensures durability
-    ///
-    /// Validates that append() calls fsync, making data durable before return.
-    /// This is tested implicitly - if fsync wasn't called, data might not survive.
-    #[test]
-    fn test_durable_log_fsync_semantics() -> Result<(), Box<dyn std::error::Error>> {
-        let temp_dir = TempDir::new()?;
-        let log_path = temp_dir.path().join("operations.log");
-
-        let mut log = OperationLog::new(&log_path)?;
-
-        for seq in 1..=100 {
-            let envelope = create_test_envelope("nodeA", seq);
-            log.append(&envelope)?; // Each append must fsync
-        }
-
-        // Verify all 100 can be loaded (fsync guarantee)
-        let loaded = log.load_all()?;
-        assert_eq!(loaded.len(), 100, "All fsync'd operations must survive");
-
-        Ok(())
-    }
-
-    /// TC-1c.1-004: Empty log recovers gracefully
-    ///
-    /// Validates recovery behavior when no log exists.
-    #[test]
-    fn test_durable_log_empty_recovery() -> Result<(), Box<dyn std::error::Error>> {
-        let temp_dir = TempDir::new()?;
-        let log_path = temp_dir.path().join("nonexistent.log");
-
-        let log = OperationLog::new(&log_path)?;
-        let loaded = log.load_all()?;
-
-        assert_eq!(loaded.len(), 0, "Nonexistent log should return empty");
-
-        Ok(())
-    }
-
-    /// TC-1c.1-005: DistributedTransactionExecutor integrates with durable log
-    ///
-    /// This validates the integration point: executor can be created with a log
-    /// and operations persist through the executor's API.
-    #[test]
-    fn test_executor_with_durable_log_integration() -> Result<(), Box<dyn std::error::Error>> {
-        use crate::distributed_transactions::DistributedTransactionExecutor;
-
-        let temp_dir = TempDir::new()?;
-        let log_path = temp_dir.path().join("operations.log");
-
-        // Create executor with durable log
-        let executor = DistributedTransactionExecutor::with_log(
-            "nodeA".to_string(),
-            StateHash::from_hex("state_v0".to_string()),
-            Some(log_path.clone()),
-        )?;
-
-        // Verify executor created successfully with log configured
-        let node_id = executor.get_local_node_id();
-        assert_eq!(node_id, "nodeA");
-
-        Ok(())
-    }
-
-    /// TC-1c.1-006: Executor recovers from persistent log
-    ///
-    /// Validates recovery mechanism: executor can load persisted operations
-    /// and rebuild dedup set from them.
-    #[test]
-    fn test_executor_recovery_from_persistent_log() -> Result<(), Box<dyn std::error::Error>> {
-        use crate::distributed_transactions::DistributedTransactionExecutor;
-
-        let temp_dir = TempDir::new()?;
-        let log_path = temp_dir.path().join("operations.log");
-
-        // Step 1: Persist some envelopes directly to log
-        {
-            let mut log = OperationLog::new(&log_path)?;
-            for seq in 1..=3 {
-                let envelope = create_test_envelope("nodeA", seq);
-                log.append(&envelope)?;
-            }
-        }
-
-        // Step 2: Create executor and load from disk
-        let mut executor = DistributedTransactionExecutor::new(
-            "nodeA".to_string(),
-            StateHash::from_hex("state_v0".to_string()),
-        );
-
-        let recovered_count = executor.load_from_disk(log_path)?;
-
-        // Step 3: Verify recovery
-        assert_eq!(recovered_count, 3, "Should recover 3 operations");
-
-        // Verify dedup set was rebuilt
-        // Note: We can't directly access envelopes_seen (it's private),
-        // but we can verify behavior through dedup prevention below
-
-        Ok(())
-    }
-}

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

@@ -1,261 +0,0 @@
-/// Track 1c.2 Acceptance Tests
-///
-/// Objective: Prove durable deduplication across process restart
-///
-/// These tests validate that:
-/// 1. Dedup set is persisted to disk alongside operation log
-/// 2. Process restart recovers persisted dedup entries
-/// 3. Duplicates are prevented even after restart
-/// 4. Dedup prevents re-application of retried operations
-
-#[cfg(test)]
-mod tests {
-    use crate::distributed_transactions::{DistributedTransactionExecutor, TransactionEnvelope};
-    use crate::durable_dedup_set::DeduplicationSet;
-    use crate::state_hash::StateHash;
-    use crate::transactions::{ConsistencyContract, ConsistencyLevel};
-    use tempfile::TempDir;
-
-    fn create_test_envelope(node: &str, sequence: u64) -> TransactionEnvelope {
-        TransactionEnvelope::new(
-            node.to_string(),
-            sequence,
-            format!("tx{}", sequence),
-            Vec::new(),
-            ConsistencyContract {
-                level: ConsistencyLevel::Causal,
-                timeout_ms: Some(1000),
-                required_acks: None,
-            },
-        )
-    }
-
-    /// TC-1c.2-001: Dedup set persists and recovers on restart
-    ///
-    /// Sequence:
-    /// 1. Create dedup set, mark several IDs as seen
-    /// 2. "Crash" (create new dedup set from same path)
-    /// 3. Verify all IDs recovered
-    #[test]
-    fn test_dedup_set_survives_restart() -> Result<(), Box<dyn std::error::Error>> {
-        let temp_dir = TempDir::new()?;
-        let dedup_path = temp_dir.path().join("dedup.set");
-
-        // Step 1: Mark IDs as seen
-        {
-            let mut dedup = DeduplicationSet::new(&dedup_path)?;
-            for seq in 1..=3 {
-                let envelope = create_test_envelope("nodeA", seq);
-                dedup.mark_seen(&envelope.envelope_id)?;
-            }
-        }
-
-        // Step 2 & 3: "Crash" and restart, verify recovery
-        {
-            let dedup = DeduplicationSet::new(&dedup_path)?;
-            let seen = dedup.load_all()?;
-
-            assert_eq!(seen.len(), 3);
-            for seq in 1..=3 {
-                let envelope = create_test_envelope("nodeA", seq);
-                assert!(seen.contains(&envelope.envelope_id));
-            }
-        }
-
-        Ok(())
-    }
-
-    /// TC-1c.2-002: Executor with durable log persists dedup set
-    ///
-    /// Sequence:
-    /// 1. Create executor with durable log
-    /// 2. Load persisted operations (simulating previously persisted state)
-    /// 3. Verify dedup set was rebuilt
-    #[test]
-    fn test_executor_dedup_persistence() -> Result<(), Box<dyn std::error::Error>> {
-        let temp_dir = TempDir::new()?;
-        let log_path = temp_dir.path().join("operations.log");
-        let dedup_path = log_path.with_extension("dedup");
-
-        // Step 1 & 2: Create executor with log and simulate loading persisted state
-        {
-            let executor = DistributedTransactionExecutor::with_log(
-                "nodeA".to_string(),
-                StateHash::from_hex("state_v0".to_string()),
-                Some(log_path.clone()),
-            )?;
-
-            // Verify executor has dedup set configured
-            let node_id = executor.get_local_node_id();
-            assert_eq!(node_id, "nodeA");
-        }
-
-        // Step 3: Create another executor and load from disk
-        {
-            let mut executor = DistributedTransactionExecutor::with_log(
-                "nodeA".to_string(),
-                StateHash::from_hex("state_v0".to_string()),
-                Some(log_path.clone()),
-            )?;
-
-            // This should set up both operation log and dedup set
-            let recovered = executor.load_from_disk(log_path)?;
-
-            // Even with no persisted operations, dedup set should be configured
-            assert_eq!(recovered, 0);
-        }
-
-        Ok(())
-    }
-
-    /// TC-1c.2-003: Multiple operations and dedup survive restart
-    ///
-    /// Sequence:
-    /// 1. Persist multiple envelopes via dedup set
-    /// 2. "Crash" and create new executor
-    /// 3. Load from disk
-    /// 4. Verify all envelopes are in dedup set
-    #[test]
-    fn test_multiple_dedup_entries_survive_restart() -> Result<(), Box<dyn std::error::Error>> {
-        let temp_dir = TempDir::new()?;
-        let dedup_path = temp_dir.path().join("dedup.set");
-
-        let mut expected_ids = Vec::new();
-
-        // Step 1: Persist multiple envelopes
-        {
-            let mut dedup = DeduplicationSet::new(&dedup_path)?;
-            for seq in 1..=10 {
-                let envelope = create_test_envelope("nodeA", seq);
-                dedup.mark_seen(&envelope.envelope_id)?;
-                expected_ids.push(envelope.envelope_id.clone());
-            }
-        }
-
-        // Step 2 & 3: "Crash" and restart
-        {
-            let dedup = DeduplicationSet::new(&dedup_path)?;
-            let seen = dedup.load_all()?;
-
-            // Step 4: Verify all envelopes recovered
-            assert_eq!(seen.len(), 10);
-            for envelope_id in expected_ids {
-                assert!(seen.contains(&envelope_id));
-            }
-        }
-
-        Ok(())
-    }
-
-    /// TC-1c.2-004: Dedup prevents duplicate after recovery
-    ///
-    /// Sequence:
-    /// 1. Persist envelope ID to dedup set
-    /// 2. "Crash" and restart
-    /// 3. Verify same envelope ID is still marked as seen
-    #[test]
-    fn test_dedup_prevents_duplicate_after_recovery() -> Result<(), Box<dyn std::error::Error>> {
-        let temp_dir = TempDir::new()?;
-        let dedup_path = temp_dir.path().join("dedup.set");
-
-        let test_envelope = create_test_envelope("nodeA", 1);
-        let test_id = test_envelope.envelope_id.clone();
-
-        // Step 1: Mark as seen
-        {
-            let mut dedup = DeduplicationSet::new(&dedup_path)?;
-            dedup.mark_seen(&test_id)?;
-        }
-
-        // Step 2 & 3: "Crash" and restart
-        let mut dedup = DeduplicationSet::new(&dedup_path)?;
-        let seen = dedup.load_all()?;
-
-        // Step 4: Verify still marked as seen (preventing duplicate)
-        assert!(seen.contains(&test_id));
-
-        Ok(())
-    }
-
-    /// TC-1c.2-005: Dedup set fsync ensures durability across restart
-    ///
-    /// Persists many entries and verifies all recover (fsync guarantee).
-    #[test]
-    fn test_dedup_set_large_scale_fsync() -> Result<(), Box<dyn std::error::Error>> {
-        let temp_dir = TempDir::new()?;
-        let dedup_path = temp_dir.path().join("dedup.set");
-
-        // Step 1: Persist 100 entries
-        {
-            let mut dedup = DeduplicationSet::new(&dedup_path)?;
-            for seq in 1..=100 {
-                let envelope = create_test_envelope("node", seq);
-                dedup.mark_seen(&envelope.envelope_id)?;
-            }
-        }
-
-        // Step 2: Recover and verify all 100 persisted
-        {
-            let dedup = DeduplicationSet::new(&dedup_path)?;
-            let seen = dedup.load_all()?;
-
-            assert_eq!(seen.len(), 100, "All fsync'd dedup entries must survive");
-        }
-
-        Ok(())
-    }
-
-    /// TC-1c.2-006: Executor recovery rebuilds dedup from persisted set
-    ///
-    /// Tests the integration: executor loads both log and dedup set, uses dedup to
-    /// prevent duplicate application.
-    #[test]
-    fn test_executor_recovery_with_dedup_integration() -> Result<(), Box<dyn std::error::Error>> {
-        let temp_dir = TempDir::new()?;
-        let log_path = temp_dir.path().join("operations.log");
-
-        // Step 1: Create executor and persist some operations
-        {
-            let executor = DistributedTransactionExecutor::with_log(
-                "nodeA".to_string(),
-                StateHash::from_hex("state_v0".to_string()),
-                Some(log_path.clone()),
-            )?;
-
-            let node_id = executor.get_local_node_id();
-            assert_eq!(node_id, "nodeA");
-        }
-
-        // Step 2: Create new executor and load from disk
-        let mut executor = DistributedTransactionExecutor::with_log(
-            "nodeA".to_string(),
-            StateHash::from_hex("state_v0".to_string()),
-            Some(log_path.clone()),
-        )?;
-
-        let recovered = executor.load_from_disk(log_path)?;
-
-        // Step 3: Verify dedup set is configured and ready
-        // (we can't directly test it without accessing the private field,
-        // but the executor loads and doesn't error)
-        assert_eq!(recovered, 0); // No operations were persisted in this test
-
-        Ok(())
-    }
-
-    /// TC-1c.2-007: Empty dedup set recovers gracefully
-    ///
-    /// Validates behavior when dedup set doesn't exist yet.
-    #[test]
-    fn test_dedup_set_empty_recovery() -> Result<(), Box<dyn std::error::Error>> {
-        let temp_dir = TempDir::new()?;
-        let dedup_path = temp_dir.path().join("nonexistent.dedup");
-
-        let dedup = DeduplicationSet::new(&dedup_path)?;
-        let seen = dedup.load_all()?;
-
-        assert_eq!(seen.len(), 0);
-
-        Ok(())
-    }
-}