@feltdb/core 0.8.4 → 0.8.5

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

@@ -24,7 +24,9 @@ mod tests {
     };
     use crate::metrics::ClusterMetrics;
     use crate::state_hash::StateHash;
-    use crate::transactions::{ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion};
+    use crate::transactions::{
+        ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion,
+    };
     use serde_json::json;
     use std::collections::HashMap;
     use std::sync::Arc;
@@ -241,14 +243,24 @@ mod tests {
             let mut report = String::new();
             report.push_str("=== Baseline Workload Report ===\n\n");
             report.push_str(&format!("Uptime: {} seconds\n", snapshot.uptime_secs));
-            report.push_str(&format!("Total Operations: {}\n", snapshot.total_operations_applied));
+            report.push_str(&format!(
+                "Total Operations: {}\n",
+                snapshot.total_operations_applied
+            ));
             report.push_str(&format!("Total Crashes: {}\n", snapshot.total_crashes));
-            report.push_str(&format!("Divergence Events: {}\n", snapshot.divergence_events));
-            report.push_str(&format!("Data Loss Events: {}\n", snapshot.data_loss_events));
+            report.push_str(&format!(
+                "Divergence Events: {}\n",
+                snapshot.divergence_events
+            ));
+            report.push_str(&format!(
+                "Data Loss Events: {}\n",
+                snapshot.data_loss_events
+            ));
             report.push_str("\nNode Metrics:\n");
 
             for node in &snapshot.node_snapshots {
-                report.push_str(&format!("  {}: {} ops applied, {} acked, {} committed\n",
+                report.push_str(&format!(
+                    "  {}: {} ops applied, {} acked, {} committed\n",
                     node.node_id,
                     node.operations_applied,
                     node.operations_acknowledged,
@@ -280,7 +292,10 @@ mod tests {
         println!("Baseline result: {:?}", result);
         println!("{}", workload.export_baseline_report());
 
-        assert!(result.total_operations > 0, "Should have processed operations");
+        assert!(
+            result.total_operations > 0,
+            "Should have processed operations"
+        );
         assert!(result.all_converged, "All nodes should converge");
         assert_eq!(result.divergences, 0, "Zero divergences during clean run");
 
@@ -295,7 +310,10 @@ mod tests {
 
         println!("Medium baseline result: {:?}", result);
 
-        assert!(result.total_operations > 100, "Should process 100+ operations");
+        assert!(
+            result.total_operations > 100,
+            "Should process 100+ operations"
+        );
         assert!(result.all_converged, "All nodes should converge");
         assert_eq!(result.divergences, 0, "Zero divergences");
 
@@ -311,7 +329,10 @@ mod tests {
         assert!(workload.verify_convergence(), "Final convergence check");
         assert_eq!(result.divergences, 0, "No divergences during baseline");
 
-        println!("✓ Convergence consistency verified over {} ops", result.total_operations);
+        println!(
+            "✓ Convergence consistency verified over {} ops",
+            result.total_operations
+        );
     }
 
     // Test 4: High-throughput baseline
@@ -320,9 +341,15 @@ mod tests {
         let workload = BaselineWorkload::new(2);
         let result = workload.run_clean_workload(20, 50);
 
-        println!("High-throughput baseline: {} ops/sec", result.throughput_ops_sec);
+        println!(
+            "High-throughput baseline: {} ops/sec",
+            result.throughput_ops_sec
+        );
 
-        assert!(result.throughput_ops_sec > 0, "Should measure positive throughput");
+        assert!(
+            result.throughput_ops_sec > 0,
+            "Should measure positive throughput"
+        );
         assert_eq!(result.divergences, 0, "Zero divergences");
 
         println!("✓ High-throughput: {} ops/sec", result.throughput_ops_sec);
@@ -339,7 +366,10 @@ mod tests {
         let json = metrics.export_json();
 
         assert!(csv.contains("leader"), "CSV should contain leader metrics");
-        assert!(json.contains("total_operations_applied"), "JSON should contain operations");
+        assert!(
+            json.contains("total_operations_applied"),
+            "JSON should contain operations"
+        );
 
         println!("✓ Metrics export validated");
     }

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

@@ -29,7 +29,9 @@ mod tests {
     };
     use crate::metrics::ClusterMetrics;
     use crate::state_hash::StateHash;
-    use crate::transactions::{ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion};
+    use crate::transactions::{
+        ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion,
+    };
     use serde_json::json;
     use std::collections::HashMap;
     use std::sync::atomic::{AtomicBool, Ordering};
@@ -48,19 +50,19 @@ mod tests {
     impl FailureInjectionConfig {
         fn default() -> Self {
             Self {
-                node_crash_interval_secs: 45,      // Every 45 seconds
-                partition_interval_secs: 180,      // Every 3 minutes
-                restart_interval_secs: 600,        // Every 10 minutes
-                compaction_interval_secs: 900,     // Every 15 minutes
+                node_crash_interval_secs: 45,  // Every 45 seconds
+                partition_interval_secs: 180,  // Every 3 minutes
+                restart_interval_secs: 600,    // Every 10 minutes
+                compaction_interval_secs: 900, // Every 15 minutes
             }
         }
 
         fn test_mode() -> Self {
             Self {
-                node_crash_interval_secs: 5,       // Every 5 seconds (for testing)
-                partition_interval_secs: 15,       // Every 15 seconds
-                restart_interval_secs: 30,         // Every 30 seconds
-                compaction_interval_secs: 60,      // Every 60 seconds
+                node_crash_interval_secs: 5,  // Every 5 seconds (for testing)
+                partition_interval_secs: 15,  // Every 15 seconds
+                restart_interval_secs: 30,    // Every 30 seconds
+                compaction_interval_secs: 60, // Every 60 seconds
             }
         }
     }
@@ -131,7 +133,9 @@ mod tests {
         }
 
         fn apply_replicated_operation(&self, message: ReplicationMessage) -> Result<(), String> {
-            if self.is_crashed.load(Ordering::Relaxed) || self.is_partitioned.load(Ordering::Relaxed) {
+            if self.is_crashed.load(Ordering::Relaxed)
+                || self.is_partitioned.load(Ordering::Relaxed)
+            {
                 return Err("Node unavailable".to_string());
             }
 
@@ -263,7 +267,9 @@ mod tests {
                 }
 
                 // Inject crashes periodically
-                if last_crash_time.elapsed().as_secs() >= self.failure_config.node_crash_interval_secs {
+                if last_crash_time.elapsed().as_secs()
+                    >= self.failure_config.node_crash_interval_secs
+                {
                     if let Some(follower) = self.followers.first() {
                         follower.crash();
                         failures_injected += 1;
@@ -277,7 +283,9 @@ mod tests {
                 }
 
                 // Inject partitions periodically
-                if last_partition_time.elapsed().as_secs() >= self.failure_config.partition_interval_secs {
+                if last_partition_time.elapsed().as_secs()
+                    >= self.failure_config.partition_interval_secs
+                {
                     if let Some(follower) = self.followers.get(1) {
                         follower.partition();
                         failures_injected += 1;
@@ -358,8 +366,10 @@ mod tests {
         assert_eq!(result.divergences, 0, "Zero divergences under failures");
         assert!(result.final_hash_match, "Final convergence achieved");
 
-        println!("✓ Short soak: {} ops, {} failures, {} divergences",
-            result.total_operations, result.failures_injected, result.divergences);
+        println!(
+            "✓ Short soak: {} ops, {} failures, {} divergences",
+            result.total_operations, result.failures_injected, result.divergences
+        );
     }
 
     // Test 2: Medium soak (60 seconds)
@@ -371,13 +381,21 @@ mod tests {
 
         println!("Medium soak result: {:?}", result);
 
-        assert!(result.total_operations > 1000, "Should process 1000+ operations");
-        assert!(result.failures_injected > 5, "Should inject multiple failures");
+        assert!(
+            result.total_operations > 1000,
+            "Should process 1000+ operations"
+        );
+        assert!(
+            result.failures_injected > 5,
+            "Should inject multiple failures"
+        );
         assert_eq!(result.divergences, 0, "Zero divergences");
         assert!(result.all_stable, "System remains stable");
 
-        println!("✓ Medium soak: {} ops, {} failures injected",
-            result.total_operations, result.failures_injected);
+        println!(
+            "✓ Medium soak: {} ops, {} failures injected",
+            result.total_operations, result.failures_injected
+        );
     }
 
     // Test 3: Verify recovery consistency
@@ -390,7 +408,10 @@ mod tests {
         assert!(result.convergence_checks > 0, "Should check convergence");
         assert_eq!(result.divergences, 0, "Recovery is consistent");
 
-        println!("✓ Recovery consistency over {} checks", result.convergence_checks);
+        println!(
+            "✓ Recovery consistency over {} checks",
+            result.convergence_checks
+        );
     }
 
     // Test 4: Long soak with stable operation
@@ -402,13 +423,21 @@ mod tests {
 
         println!("Long soak result: {:?}", result);
 
-        assert!(result.total_operations > 2000, "Should process 2000+ operations");
-        assert!(result.all_stable, "System remains stable under sustained load");
+        assert!(
+            result.total_operations > 2000,
+            "Should process 2000+ operations"
+        );
+        assert!(
+            result.all_stable,
+            "System remains stable under sustained load"
+        );
         assert_eq!(result.divergences, 0, "No divergences over extended period");
         assert!(result.final_hash_match, "Final state converges");
 
-        println!("✓ Long soak: {} ops under {} failures",
-            result.total_operations, result.failures_injected);
+        println!(
+            "✓ Long soak: {} ops under {} failures",
+            result.total_operations, result.failures_injected
+        );
     }
 
     // Test 5: Metrics validation during soak
@@ -424,7 +453,9 @@ mod tests {
         assert!(snapshot.divergence_events >= 0, "Metrics track divergences");
         assert_eq!(snapshot.data_loss_events, 0, "No data loss detected");
 
-        println!("✓ Metrics: {} divergence events, {} data loss events",
-            snapshot.divergence_events, snapshot.data_loss_events);
+        println!(
+            "✓ Metrics: {} divergence events, {} data loss events",
+            snapshot.divergence_events, snapshot.data_loss_events
+        );
     }
 }