@feltdb/core 0.13.0 → 0.16.0

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

@@ -1,289 +0,0 @@
-/// Permutation Scheduler for Convergence Testing
-///
-/// Generates multiple orderings of the same operation set to test
-/// whether independent nodes converge to identical state regardless
-/// of message delivery order.
-use crate::transactions::Operation;
-use rand::seq::SliceRandom;
-use rand::SeedableRng;
-
-/// Different scheduling strategies for operation ordering
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum ScheduleStrategy {
-    /// Original order (baseline)
-    Original,
-    /// Reverse order
-    Reversed,
-    /// Sorted by operation ID
-    SortedById,
-    /// Random shuffle with fixed seed for reproducibility
-    RandomSeed { seed: u64 },
-}
-
-/// A specific ordering of operations
-#[derive(Clone, Debug)]
-pub struct OperationSchedule {
-    pub strategy: ScheduleStrategy,
-    pub operations: Vec<Operation>,
-}
-
-impl OperationSchedule {
-    pub fn new(strategy: ScheduleStrategy, operations: Vec<Operation>) -> Self {
-        Self {
-            strategy,
-            operations,
-        }
-    }
-
-    pub fn id(&self) -> String {
-        format!("{:?}", self.strategy)
-    }
-}
-
-/// Generates diverse operation schedules for convergence testing
-pub struct PermutationScheduler;
-
-impl PermutationScheduler {
-    /// Generate all deterministic permutations (original, reversed, sorted)
-    /// Use this for small operation sets where all permutations are feasible
-    pub fn deterministic_schedules(operations: &[Operation]) -> Vec<OperationSchedule> {
-        vec![
-            OperationSchedule::new(ScheduleStrategy::Original, operations.to_vec()),
-            OperationSchedule::new(ScheduleStrategy::Reversed, {
-                let mut ops = operations.to_vec();
-                ops.reverse();
-                ops
-            }),
-            OperationSchedule::new(ScheduleStrategy::SortedById, {
-                let mut ops = operations.to_vec();
-                ops.sort_by(|a, b| a.operation_id.sequence.cmp(&b.operation_id.sequence));
-                ops
-            }),
-        ]
-    }
-
-    /// Generate N random permutations with different seeds
-    /// Use this for large operation sets where exhaustive permutation is infeasible
-    pub fn random_schedules(operations: &[Operation], count: usize) -> Vec<OperationSchedule> {
-        (0..count)
-            .map(|i| {
-                let seed = i as u64;
-                let mut rng = rand::rngs::StdRng::seed_from_u64(seed);
-                let mut ops = operations.to_vec();
-                ops.shuffle(&mut rng);
-
-                OperationSchedule::new(ScheduleStrategy::RandomSeed { seed }, ops)
-            })
-            .collect()
-    }
-
-    /// Generate a comprehensive test set:
-    /// - All deterministic permutations
-    /// - N random permutations
-    pub fn comprehensive_schedules(
-        operations: &[Operation],
-        random_count: usize,
-    ) -> Vec<OperationSchedule> {
-        let mut schedules = Self::deterministic_schedules(operations);
-        schedules.extend(Self::random_schedules(operations, random_count));
-        schedules
-    }
-
-    /// Generate minimal test set (fast iteration)
-    /// - Original
-    /// - Reversed
-    /// - 5 random permutations
-    pub fn minimal_schedules(operations: &[Operation]) -> Vec<OperationSchedule> {
-        Self::comprehensive_schedules(operations, 5)
-    }
-
-    /// Generate standard test set (good coverage)
-    /// - Original
-    /// - Reversed
-    /// - Sorted
-    /// - 50 random permutations
-    pub fn standard_schedules(operations: &[Operation]) -> Vec<OperationSchedule> {
-        Self::comprehensive_schedules(operations, 50)
-    }
-
-    /// Generate thorough test set (exhaustive)
-    /// - Original
-    /// - Reversed
-    /// - Sorted
-    /// - 1000 random permutations
-    pub fn thorough_schedules(operations: &[Operation]) -> Vec<OperationSchedule> {
-        Self::comprehensive_schedules(operations, 1000)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::convergence::VectorClock;
-    use crate::transactions::{OperationCommand, OperationId, StateVersion};
-    use std::collections::HashMap;
-
-    fn create_test_operation(seq: u64, collection: &str, record_id: &str, value: i32) -> Operation {
-        let mut vc = VectorClock::new();
-        vc.increment("test_node");
-        let version = StateVersion::new(vc, "test_hash".to_string());
-
-        Operation::new(
-            OperationId::new("test_node".to_string(), seq),
-            version,
-            format!("Op{}", seq),
-            OperationCommand {
-                op_type: "UpdateField".to_string(),
-                collection: collection.to_string(),
-                record_id: record_id.to_string(),
-                fields: {
-                    let mut m = HashMap::new();
-                    m.insert("value".to_string(), serde_json::json!(value));
-                    m
-                },
-            },
-            "test".to_string(),
-        )
-    }
-
-    #[test]
-    fn test_deterministic_schedules() {
-        let ops = vec![
-            create_test_operation(1, "records", "rec1", 10),
-            create_test_operation(2, "records", "rec2", 20),
-            create_test_operation(3, "records", "rec3", 30),
-        ];
-
-        let schedules = PermutationScheduler::deterministic_schedules(&ops);
-        assert_eq!(schedules.len(), 3); // original, reversed, sorted
-    }
-
-    #[test]
-    fn test_random_schedules() {
-        let ops = vec![
-            create_test_operation(1, "records", "rec1", 10),
-            create_test_operation(2, "records", "rec2", 20),
-        ];
-
-        let schedules = PermutationScheduler::random_schedules(&ops, 10);
-        assert_eq!(schedules.len(), 10);
-
-        // All should be RandomSeed variants
-        for schedule in &schedules {
-            assert!(matches!(
-                schedule.strategy,
-                ScheduleStrategy::RandomSeed { .. }
-            ));
-        }
-    }
-
-    #[test]
-    fn test_random_schedules_deterministic() {
-        let ops = vec![
-            create_test_operation(1, "records", "rec1", 10),
-            create_test_operation(2, "records", "rec2", 20),
-        ];
-
-        let schedules1 = PermutationScheduler::random_schedules(&ops, 3);
-        let schedules2 = PermutationScheduler::random_schedules(&ops, 3);
-
-        // Same seed should produce same order
-        for i in 0..3 {
-            let ops1: Vec<u64> = schedules1[i]
-                .operations
-                .iter()
-                .map(|o| o.operation_id.sequence)
-                .collect();
-            let ops2: Vec<u64> = schedules2[i]
-                .operations
-                .iter()
-                .map(|o| o.operation_id.sequence)
-                .collect();
-            assert_eq!(ops1, ops2);
-        }
-    }
-
-    #[test]
-    fn test_comprehensive_schedules() {
-        let ops = vec![
-            create_test_operation(1, "records", "rec1", 10),
-            create_test_operation(2, "records", "rec2", 20),
-            create_test_operation(3, "records", "rec3", 30),
-        ];
-
-        let schedules = PermutationScheduler::comprehensive_schedules(&ops, 5);
-        assert_eq!(schedules.len(), 3 + 5); // 3 deterministic + 5 random
-    }
-
-    #[test]
-    fn test_minimal_schedules() {
-        let ops = vec![
-            create_test_operation(1, "records", "rec1", 10),
-            create_test_operation(2, "records", "rec2", 20),
-        ];
-
-        let schedules = PermutationScheduler::minimal_schedules(&ops);
-        assert_eq!(schedules.len(), 3 + 5); // deterministic + 5 random
-    }
-
-    #[test]
-    fn test_schedule_preserves_all_operations() {
-        let ops = vec![
-            create_test_operation(1, "records", "rec1", 10),
-            create_test_operation(2, "records", "rec2", 20),
-            create_test_operation(3, "records", "rec3", 30),
-        ];
-
-        let schedules = PermutationScheduler::comprehensive_schedules(&ops, 10);
-
-        for schedule in &schedules {
-            assert_eq!(schedule.operations.len(), 3);
-            let seq: Vec<u64> = schedule
-                .operations
-                .iter()
-                .map(|o| o.operation_id.sequence)
-                .collect();
-            assert!(seq.contains(&1));
-            assert!(seq.contains(&2));
-            assert!(seq.contains(&3));
-        }
-    }
-
-    #[test]
-    fn test_original_schedule_preserves_order() {
-        let ops = vec![
-            create_test_operation(1, "records", "rec1", 10),
-            create_test_operation(2, "records", "rec2", 20),
-            create_test_operation(3, "records", "rec3", 30),
-        ];
-
-        let schedules = PermutationScheduler::deterministic_schedules(&ops);
-        let original = &schedules[0];
-
-        let seq: Vec<u64> = original
-            .operations
-            .iter()
-            .map(|o| o.operation_id.sequence)
-            .collect();
-        assert_eq!(seq, vec![1, 2, 3]);
-    }
-
-    #[test]
-    fn test_reversed_schedule() {
-        let ops = vec![
-            create_test_operation(1, "records", "rec1", 10),
-            create_test_operation(2, "records", "rec2", 20),
-            create_test_operation(3, "records", "rec3", 30),
-        ];
-
-        let schedules = PermutationScheduler::deterministic_schedules(&ops);
-        let reversed = &schedules[1];
-
-        let seq: Vec<u64> = reversed
-            .operations
-            .iter()
-            .map(|o| o.operation_id.sequence)
-            .collect();
-        assert_eq!(seq, vec![3, 2, 1]);
-    }
-}