@feltdb/core 0.8.4 → 0.8.5

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

@@ -84,7 +84,9 @@ mod tests {
         let record = node.build("tx-reject", operations);
 
         match node.commit(&record)? {
-            ApplyOutcome::Rejected(RejectionReason::PreconditionFailed { operation_index, .. }) => {
+            ApplyOutcome::Rejected(RejectionReason::PreconditionFailed {
+                operation_index, ..
+            }) => {
                 assert_eq!(operation_index, 1);
             }
             other => panic!("expected a precondition rejection, got {:?}", other),
@@ -93,18 +95,28 @@ mod tests {
         // A rejected transaction must leave nothing behind, including the
         // operations that were legal on their own.
         assert_eq!(visible(&node, &record), 0, "no operation may be visible");
-        assert!(node.state().get_record("accounts", "A").is_none(), "A must not be applied");
-        assert!(node.state().get_record("accounts", "C").is_none(), "C must not be applied");
+        assert!(
+            node.state().get_record("accounts", "A").is_none(),
+            "A must not be applied"
+        );
+        assert!(
+            node.state().get_record("accounts", "C").is_none(),
+            "C must not be applied"
+        );
 
         drop(node);
         let (restarted, report) = TransactionalNode::open(&path, "node1")?;
-        assert!(report.committed.is_empty(), "a rejected transaction must never be logged");
+        assert!(
+            report.committed.is_empty(),
+            "a rejected transaction must never be logged"
+        );
         assert!(restarted.state().get_record("accounts", "A").is_none());
         Ok(())
     }
 
     #[test]
-    fn a_transaction_writing_one_record_twice_is_refused() -> Result<(), Box<dyn std::error::Error>> {
+    fn a_transaction_writing_one_record_twice_is_refused() -> Result<(), Box<dyn std::error::Error>>
+    {
         let dir = TempDir::new()?;
         let (mut node, _) = TransactionalNode::open(dir.path().join("tx.log"), "node1")?;
 
@@ -137,8 +149,12 @@ mod tests {
             CrashPoint::DuringWrite { keep_percent: 90 },
             CrashPoint::AfterWriteBeforeFsync,
             CrashPoint::AfterFsyncBeforeApply,
-            CrashPoint::DuringApply { after_operations: 1 },
-            CrashPoint::DuringApply { after_operations: 2 },
+            CrashPoint::DuringApply {
+                after_operations: 1,
+            },
+            CrashPoint::DuringApply {
+                after_operations: 2,
+            },
             CrashPoint::AfterApply,
         ];
 
@@ -162,14 +178,22 @@ mod tests {
                 // Nothing durable was written, so nothing may be visible.
                 CrashPoint::BeforeWrite | CrashPoint::DuringWrite { .. } => {
                     assert!(!fully_visible, "{}: nothing should have committed", context);
-                    assert!(report.committed.is_empty(), "{}: log must hold no record", context);
+                    assert!(
+                        report.committed.is_empty(),
+                        "{}: log must hold no record",
+                        context
+                    );
                 }
                 // The record was fsynced, so recovery must replay all of it —
                 // including when the crash happened part-way through applying.
                 CrashPoint::AfterFsyncBeforeApply
                 | CrashPoint::DuringApply { .. }
                 | CrashPoint::AfterApply => {
-                    assert!(fully_visible, "{}: a committed transaction must fully recover", context);
+                    assert!(
+                        fully_visible,
+                        "{}: a committed transaction must fully recover",
+                        context
+                    );
                     assert_eq!(report.committed.len(), 1, "{}", context);
                 }
                 // Written but not fsynced: the operating system decides. Either
@@ -182,8 +206,8 @@ mod tests {
     }
 
     #[test]
-    fn a_torn_final_record_is_discarded_and_the_log_stays_writable()
-    -> Result<(), Box<dyn std::error::Error>> {
+    fn a_torn_final_record_is_discarded_and_the_log_stays_writable(
+    ) -> Result<(), Box<dyn std::error::Error>> {
         let dir = TempDir::new()?;
         let path = dir.path().join("tx.log");
 
@@ -200,7 +224,10 @@ mod tests {
         // Recovery keeps the committed transaction and discards the torn one.
         let (mut node, report) = TransactionalNode::open(&path, "node1")?;
         assert_eq!(report.committed.len(), 1);
-        assert!(matches!(report.discarded_tail, Some(LogDefect::TornTail { .. })));
+        assert!(matches!(
+            report.discarded_tail,
+            Some(LogDefect::TornTail { .. })
+        ));
         assert_eq!(visible(&node, &first), 3);
 
         // The torn bytes were truncated, so a later write cannot splice onto
@@ -210,7 +237,10 @@ mod tests {
         drop(node);
 
         let (again, report) = TransactionalNode::open(&path, "node1")?;
-        assert!(report.discarded_tail.is_none(), "the log must be clean after truncation");
+        assert!(
+            report.discarded_tail.is_none(),
+            "the log must be clean after truncation"
+        );
         assert_eq!(report.committed.len(), 2);
         assert_eq!(visible(&again, &first), 3);
         assert_eq!(visible(&again, &third), 3);
@@ -218,7 +248,8 @@ mod tests {
     }
 
     #[test]
-    fn interior_corruption_is_refused_rather_than_guessed() -> Result<(), Box<dyn std::error::Error>> {
+    fn interior_corruption_is_refused_rather_than_guessed() -> Result<(), Box<dyn std::error::Error>>
+    {
         let dir = TempDir::new()?;
         let path = dir.path().join("tx.log");
 
@@ -234,9 +265,19 @@ mod tests {
         drop(node);
 
         let outcome = TransactionalNode::open(&path, "node1");
-        assert!(outcome.is_err(), "recovery must refuse a corrupted interior record");
-        let message = outcome.err().map(|error| error.to_string()).unwrap_or_default();
-        assert!(message.contains("corrupted"), "unexpected error: {}", message);
+        assert!(
+            outcome.is_err(),
+            "recovery must refuse a corrupted interior record"
+        );
+        let message = outcome
+            .err()
+            .map(|error| error.to_string())
+            .unwrap_or_default();
+        assert!(
+            message.contains("corrupted"),
+            "unexpected error: {}",
+            message
+        );
         Ok(())
     }
 
@@ -247,15 +288,23 @@ mod tests {
 
         // Alter the body without recomputing the checksum, as a partial write
         // or a bit flip would.
-        record.operations.push(TransactionOperation::set("accounts", "D", json!({ "balance": 9 })));
-        assert!(!record.verify_checksum(), "a mutated record must fail its integrity check");
+        record.operations.push(TransactionOperation::set(
+            "accounts",
+            "D",
+            json!({ "balance": 9 }),
+        ));
+        assert!(
+            !record.verify_checksum(),
+            "a mutated record must fail its integrity check"
+        );
         Ok(())
     }
 
     // ---------------------------------------------------------------- replay
 
     #[test]
-    fn replaying_a_committed_transaction_changes_nothing() -> Result<(), Box<dyn std::error::Error>> {
+    fn replaying_a_committed_transaction_changes_nothing() -> Result<(), Box<dyn std::error::Error>>
+    {
         let dir = TempDir::new()?;
         let (mut node, _) = TransactionalNode::open(dir.path().join("tx.log"), "node1")?;
 
@@ -265,10 +314,17 @@ mod tests {
 
         // Deliver the same transaction repeatedly.
         for _ in 0..5 {
-            assert_eq!(node.accept_replicated(&record)?, ApplyOutcome::AlreadyApplied);
+            assert_eq!(
+                node.accept_replicated(&record)?,
+                ApplyOutcome::AlreadyApplied
+            );
         }
 
-        assert_eq!(node.state().hash().as_hex(), hash_after_first, "replay must not change state");
+        assert_eq!(
+            node.state().hash().as_hex(),
+            hash_after_first,
+            "replay must not change state"
+        );
         Ok(())
     }
 
@@ -292,8 +348,10 @@ mod tests {
             hashes.push(node.state().hash().as_hex().to_string());
         }
 
-        assert!(hashes.windows(2).all(|pair| pair[0] == pair[1]),
-            "every restart must recover identical state");
+        assert!(
+            hashes.windows(2).all(|pair| pair[0] == pair[1]),
+            "every restart must recover identical state"
+        );
         Ok(())
     }
 
@@ -320,7 +378,11 @@ mod tests {
         assert_eq!(report.committed.len(), 3);
         for index in 1..=3 {
             let key = format!("A-tx{}", index);
-            assert!(node.state().get_record("accounts", &key).is_some(), "tx{} lost", index);
+            assert!(
+                node.state().get_record("accounts", &key).is_some(),
+                "tx{} lost",
+                index
+            );
         }
         Ok(())
     }
@@ -353,15 +415,23 @@ mod tests {
         }
 
         // Sequences are unique and ordered, so the log defines one history.
-        let sequences: Vec<u64> = report.committed.iter().map(|record| record.sequence).collect();
+        let sequences: Vec<u64> = report
+            .committed
+            .iter()
+            .map(|record| record.sequence)
+            .collect();
         let unique: HashSet<u64> = sequences.iter().copied().collect();
         assert_eq!(unique.len(), sequences.len(), "sequences must be unique");
-        assert!(sequences.windows(2).all(|pair| pair[0] < pair[1]), "log must be ordered");
+        assert!(
+            sequences.windows(2).all(|pair| pair[0] < pair[1]),
+            "log must be ordered"
+        );
         Ok(())
     }
 
     #[test]
-    fn a_losing_writer_is_rejected_without_partial_effect() -> Result<(), Box<dyn std::error::Error>> {
+    fn a_losing_writer_is_rejected_without_partial_effect() -> Result<(), Box<dyn std::error::Error>>
+    {
         let dir = TempDir::new()?;
         let path = dir.path().join("tx.log");
         let (mut node, _) = TransactionalNode::open(&path, "node1")?;
@@ -389,9 +459,14 @@ mod tests {
         assert!(matches!(node.commit(&second)?, ApplyOutcome::Rejected(_)));
 
         // The loser must leave nothing behind, including its uncontended write.
-        assert!(node.state().get_record("accounts", "only-b").is_none(),
-            "a rejected transaction must not apply its other operations");
-        assert_eq!(node.state().get_record("accounts", "shared"), Some(&json!({ "owner": "a" })));
+        assert!(
+            node.state().get_record("accounts", "only-b").is_none(),
+            "a rejected transaction must not apply its other operations"
+        );
+        assert_eq!(
+            node.state().get_record("accounts", "shared"),
+            Some(&json!({ "owner": "a" }))
+        );
         drop(node);
 
         let (recovered, report) = TransactionalNode::open(&path, "node1")?;
@@ -412,16 +487,36 @@ mod tests {
         let record = leader.build("tx1", abc("tx1"));
         assert_eq!(leader.commit(&record)?, ApplyOutcome::Applied);
 
-        assert_eq!(follower_b.accept_replicated(&record)?, ApplyOutcome::Applied);
-        assert_eq!(follower_c.accept_replicated(&record)?, ApplyOutcome::Applied);
+        assert_eq!(
+            follower_b.accept_replicated(&record)?,
+            ApplyOutcome::Applied
+        );
+        assert_eq!(
+            follower_c.accept_replicated(&record)?,
+            ApplyOutcome::Applied
+        );
 
         // Duplicate delivery is safe.
-        assert_eq!(follower_b.accept_replicated(&record)?, ApplyOutcome::AlreadyApplied);
-        assert_eq!(follower_c.accept_replicated(&record)?, ApplyOutcome::AlreadyApplied);
+        assert_eq!(
+            follower_b.accept_replicated(&record)?,
+            ApplyOutcome::AlreadyApplied
+        );
+        assert_eq!(
+            follower_c.accept_replicated(&record)?,
+            ApplyOutcome::AlreadyApplied
+        );
 
         let leader_hash = leader.state().hash().as_hex().to_string();
-        assert_eq!(follower_b.state().hash().as_hex(), leader_hash, "B diverged");
-        assert_eq!(follower_c.state().hash().as_hex(), leader_hash, "C diverged");
+        assert_eq!(
+            follower_b.state().hash().as_hex(),
+            leader_hash,
+            "B diverged"
+        );
+        assert_eq!(
+            follower_c.state().hash().as_hex(),
+            leader_hash,
+            "C diverged"
+        );
 
         for node in [&follower_b, &follower_c] {
             assert_atomic(node, &record, "replicated follower");
@@ -430,8 +525,8 @@ mod tests {
     }
 
     #[test]
-    fn a_follower_that_crashes_mid_replication_recovers_atomically()
-    -> Result<(), Box<dyn std::error::Error>> {
+    fn a_follower_that_crashes_mid_replication_recovers_atomically(
+    ) -> Result<(), Box<dyn std::error::Error>> {
         let dir = TempDir::new()?;
         let leader_path = dir.path().join("a.log");
         let follower_path = dir.path().join("b.log");
@@ -450,27 +545,40 @@ mod tests {
         }
 
         let (mut follower, report) = TransactionalNode::open(&follower_path, "nodeB")?;
-        assert!(report.committed.is_empty(), "a torn replicated record must not commit");
+        assert!(
+            report.committed.is_empty(),
+            "a torn replicated record must not commit"
+        );
         assert_atomic(&follower, &record, "follower after torn write");
         assert_eq!(follower.executor().visible_operations(&record), 0);
 
         // Retransmission after recovery succeeds and converges.
         assert_eq!(follower.accept_replicated(&record)?, ApplyOutcome::Applied);
         let (leader, _) = TransactionalNode::open(&leader_path, "nodeA")?;
-        assert_eq!(follower.state().hash().as_hex(), leader.state().hash().as_hex());
+        assert_eq!(
+            follower.state().hash().as_hex(),
+            leader.state().hash().as_hex()
+        );
         Ok(())
     }
 
     #[test]
-    fn a_replicated_record_that_fails_integrity_is_refused() -> Result<(), Box<dyn std::error::Error>> {
+    fn a_replicated_record_that_fails_integrity_is_refused(
+    ) -> Result<(), Box<dyn std::error::Error>> {
         let dir = TempDir::new()?;
         let (mut follower, _) = TransactionalNode::open(dir.path().join("b.log"), "nodeB")?;
 
         let mut record = TransactionRecord::new("tx1", "nodeA", 1, abc("tx1"));
         record.operations[0].record_id = "tampered".to_string();
 
-        assert!(matches!(follower.accept_replicated(&record)?, ApplyOutcome::Rejected(_)));
-        assert!(follower.state().records.is_empty(), "a tampered record must not apply");
+        assert!(matches!(
+            follower.accept_replicated(&record)?,
+            ApplyOutcome::Rejected(_)
+        ));
+        assert!(
+            follower.state().records.is_empty(),
+            "a tampered record must not apply"
+        );
         Ok(())
     }
 
@@ -490,11 +598,16 @@ mod tests {
 
         let (mut node, report) = TransactionalNode::open(&path, "node1")?;
         assert_eq!(report.committed[0].transaction_id, "stable-id");
-        assert!(node.executor().applied_transactions().contains("stable-id"),
-            "identity must be restored so replay stays idempotent");
+        assert!(
+            node.executor().applied_transactions().contains("stable-id"),
+            "identity must be restored so replay stays idempotent"
+        );
 
         // Redelivery after restart is still a no-op.
-        assert_eq!(node.accept_replicated(&record)?, ApplyOutcome::AlreadyApplied);
+        assert_eq!(
+            node.accept_replicated(&record)?,
+            ApplyOutcome::AlreadyApplied
+        );
         Ok(())
     }
 
@@ -526,23 +639,34 @@ mod tests {
         drop(node);
 
         let (recovered, _) = TransactionalNode::open(&path, "node1")?;
-        assert!(recovered.state().get_record("accounts", "old").is_none(), "delete must persist");
-        assert!(recovered.state().get_record("accounts", "new").is_some(), "insert must persist");
-        assert!(recovered.state().get_record("accounts", "keep").is_some(), "untouched record kept");
+        assert!(
+            recovered.state().get_record("accounts", "old").is_none(),
+            "delete must persist"
+        );
+        assert!(
+            recovered.state().get_record("accounts", "new").is_some(),
+            "insert must persist"
+        );
+        assert!(
+            recovered.state().get_record("accounts", "keep").is_some(),
+            "untouched record kept"
+        );
         Ok(())
     }
 
     /// A long mixed history under repeated crashes: no transaction may ever be
     /// partially visible, at any point, under any interleaving.
     #[test]
-    fn a_long_crash_ridden_history_never_exposes_a_partial_transaction()
-    -> Result<(), Box<dyn std::error::Error>> {
+    fn a_long_crash_ridden_history_never_exposes_a_partial_transaction(
+    ) -> Result<(), Box<dyn std::error::Error>> {
         let dir = TempDir::new()?;
         let path = dir.path().join("tx.log");
         let crashes = [
             CrashPoint::AfterApply,
             CrashPoint::DuringWrite { keep_percent: 30 },
-            CrashPoint::DuringApply { after_operations: 2 },
+            CrashPoint::DuringApply {
+                after_operations: 2,
+            },
             CrashPoint::BeforeWrite,
             CrashPoint::AfterFsyncBeforeApply,
             CrashPoint::DuringWrite { keep_percent: 80 },
@@ -567,14 +691,26 @@ mod tests {
         // Final state: every transaction is wholly present or wholly absent,
         // and the committed count matches what the log actually holds.
         let (recovered, report) = TransactionalNode::open(&path, "node1")?;
-        let committed_ids: HashSet<String> =
-            report.committed.iter().map(|record| record.transaction_id.clone()).collect();
+        let committed_ids: HashSet<String> = report
+            .committed
+            .iter()
+            .map(|record| record.transaction_id.clone())
+            .collect();
         for record in &issued {
             let seen = recovered.executor().visible_operations(record);
             if committed_ids.contains(&record.transaction_id) {
-                assert_eq!(seen, record.operations.len(), "{} committed but not whole", record.transaction_id);
+                assert_eq!(
+                    seen,
+                    record.operations.len(),
+                    "{} committed but not whole",
+                    record.transaction_id
+                );
             } else {
-                assert_eq!(seen, 0, "{} not committed but visible", record.transaction_id);
+                assert_eq!(
+                    seen, 0,
+                    "{} not committed but visible",
+                    record.transaction_id
+                );
             }
         }
         Ok(())

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

@@ -18,7 +18,6 @@
 ///
 /// Critical invariant: If A and B eventually receive all operations
 /// (in any order), they converge to the same state_hash.
-
 use crate::convergence::VectorClock;
 use crate::state_hash::CanonicalState;
 use std::collections::HashMap;
@@ -90,51 +89,53 @@ impl PartitionedReplica {
     }
 
     /// Apply an operation to partition A
-    pub fn apply_to_partition_a(
-        &mut self,
-        operation_id: &str,
-        record_id: &str,
-        value: i32,
-    ) {
+    pub fn apply_to_partition_a(&mut self, operation_id: &str, record_id: &str, value: i32) {
         if self.connected {
             // Both partitions receive the operation
             self.apply_to_both(operation_id, record_id, value);
         } else {
             // Only A receives it
-            self.partition_a.apply_operation(operation_id, record_id, value);
+            self.partition_a
+                .apply_operation(operation_id, record_id, value);
         }
     }
 
     /// Apply an operation to partition B
-    pub fn apply_to_partition_b(
-        &mut self,
-        operation_id: &str,
-        record_id: &str,
-        value: i32,
-    ) {
+    pub fn apply_to_partition_b(&mut self, operation_id: &str, record_id: &str, value: i32) {
         if self.connected {
             // Both partitions receive the operation
             self.apply_to_both(operation_id, record_id, value);
         } else {
             // Only B receives it
-            self.partition_b.apply_operation(operation_id, record_id, value);
+            self.partition_b
+                .apply_operation(operation_id, record_id, value);
         }
     }
 
     /// Apply operation to both partitions (when connected)
     fn apply_to_both(&mut self, operation_id: &str, record_id: &str, value: i32) {
-        self.partition_a.apply_operation(operation_id, record_id, value);
-        self.partition_b.apply_operation(operation_id, record_id, value);
+        self.partition_a
+            .apply_operation(operation_id, record_id, value);
+        self.partition_b
+            .apply_operation(operation_id, record_id, value);
     }
 
     /// Reconcile the two partitions using operation-based reconciliation
     /// Ensures all operations from both partitions are applied to both
     pub fn reconcile(&self) -> ReconciliationResult {
         // Collect all operations from both partitions
-        let mut ops_from_a: std::collections::HashSet<_> =
-            self.partition_a.applied_operations.iter().cloned().collect();
-        let ops_from_b: std::collections::HashSet<_> =
-            self.partition_b.applied_operations.iter().cloned().collect();
+        let mut ops_from_a: std::collections::HashSet<_> = self
+            .partition_a
+            .applied_operations
+            .iter()
+            .cloned()
+            .collect();
+        let ops_from_b: std::collections::HashSet<_> = self
+            .partition_b
+            .applied_operations
+            .iter()
+            .cloned()
+            .collect();
 
         // Find duplicates and unique ops
         let duplicates: Vec<String> = ops_from_a
@@ -248,9 +249,7 @@ pub struct PartitionTrace {
 
 impl PartitionDeterminismChecker {
     pub fn new() -> Self {
-        Self {
-            traces: Vec::new(),
-        }
+        Self { traces: Vec::new() }
     }
 
     /// Record a scenario's outcome
@@ -414,7 +413,12 @@ mod tests {
         );
 
         let result = checker.verify_determinism();
-        assert_eq!(result, DeterminismCheckResult::Satisfied { scenarios_checked: 2 });
+        assert_eq!(
+            result,
+            DeterminismCheckResult::Satisfied {
+                scenarios_checked: 2
+            }
+        );
     }
 
     #[test]
@@ -471,7 +475,13 @@ mod tests {
         assert_eq!(partitioned.partition_b.applied_operations.len(), 3);
 
         // But A still has op1 and B still has op2 (not synchronized yet)
-        assert!(partitioned.partition_a.applied_operations.contains(&"op1".to_string()));
-        assert!(partitioned.partition_b.applied_operations.contains(&"op2".to_string()));
+        assert!(partitioned
+            .partition_a
+            .applied_operations
+            .contains(&"op1".to_string()));
+        assert!(partitioned
+            .partition_b
+            .applied_operations
+            .contains(&"op2".to_string()));
     }
 }