leptos-sync-core 0.9.0

Core synchronization library for Leptos applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

//! Basic CRDT implementations
//!
//! This module provides fundamental CRDT types including:
//! - ReplicaId: Unique identifier for replicas
//! - LwwRegister: Last-Write-Wins Register
//! - LwwMap: Last-Write-Wins Map
//! - GCounter: Grow-only Counter

pub mod counter;
pub mod lww_map;
pub mod lww_register;
pub mod replica_id;
pub mod traits;

// Re-export main types for convenience
pub use counter::GCounter;
pub use lww_map::LwwMap;
pub use lww_register::LwwRegister;
pub use replica_id::ReplicaId;
pub use traits::{CRDT, Mergeable};

#[cfg(test)]
mod integration_tests {
    use super::*;

    #[test]
    fn test_basic_crdt_integration() {
        let replica_id = ReplicaId::default();

        // Test LwwRegister
        let mut register = LwwRegister::new("initial", replica_id);
        register.update("updated", replica_id);
        assert_eq!(register.value(), &"updated");

        // Test LwwMap
        let mut map = LwwMap::new();
        map.insert("key1", "value1", replica_id);
        assert_eq!(map.get(&"key1"), Some(&"value1"));

        // Test GCounter
        let mut counter = GCounter::new();
        counter.increment(replica_id);
        counter.increment(replica_id);
        assert_eq!(counter.value(), 2);
    }

    #[test]
    fn test_crdt_traits_implementation() {
        let replica_id = ReplicaId::default();

        // Test that all basic CRDT types implement the required traits
        let register: LwwRegister<String> = LwwRegister::new("test".to_string(), replica_id);
        let map: LwwMap<String, String> = LwwMap::new();
        let counter = GCounter::new();

        // This should compile if all types implement CRDT trait
        let _: &dyn CRDT = &register;
        let _: &dyn CRDT = &map;
        let _: &dyn CRDT = &counter;
    }

    #[test]
    fn test_mergeable_traits_implementation() {
        let replica_id = ReplicaId::default();

        // Test LwwRegister merge
        let mut reg1 = LwwRegister::new("value1", replica_id);
        let reg2 = LwwRegister::new("value2", replica_id);

        std::thread::sleep(std::time::Duration::from_millis(1));
        reg1.merge(&reg2).unwrap();
        assert_eq!(reg1.value(), &"value2");

        // Test LwwMap merge
        let mut map1 = LwwMap::new();
        let mut map2 = LwwMap::new();

        map1.insert("key1", "value1", replica_id);
        map2.insert("key2", "value2", replica_id);

        map1.merge(&map2).unwrap();
        assert_eq!(map1.len(), 2);

        // Test GCounter merge
        let mut counter1 = GCounter::new();
        let mut counter2 = GCounter::new();

        counter1.increment(replica_id);
        counter2.increment(replica_id);
        counter2.increment(replica_id);

        counter1.merge(&counter2).unwrap();
        assert_eq!(counter1.value(), 2);
    }

    #[test]
    fn test_replica_id_usage() {
        let replica_id1 = ReplicaId::default();
        let replica_id2 = ReplicaId::default();

        // Test that different replicas are different
        assert_ne!(replica_id1, replica_id2);

        // Test serialization
        let serialized = serde_json::to_string(&replica_id1).unwrap();
        let deserialized: ReplicaId = serde_json::from_str(&serialized).unwrap();
        assert_eq!(replica_id1, deserialized);
    }
}