aper 0.5.0

Synchronized state machines over WebSockets
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
110
111
112
113
114
115
116
117
118
119
120

use aper::{data_structures::atom::Atom, Aper, AperClient, AperServer, AperSync, StoreHandle};
use serde::{Deserialize, Serialize};

struct Counter(Atom<u64>);

impl AperSync for Counter {
    fn attach(map: StoreHandle) -> Self {
        Self(Atom::attach(map))
    }
}

impl Counter {
    fn get(&self) -> u64 {
        self.0.get()
    }
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
enum CounterIntent {
    IncrementBy(u64),
    SetTo(u64),
}

impl Aper for Counter {
    type Intent = CounterIntent;
    type Error = ();

    fn apply(&mut self, intent: &Self::Intent) -> Result<(), Self::Error> {
        match intent {
            CounterIntent::IncrementBy(amount) => {
                self.0.set(self.0.get() + amount);
            }
            CounterIntent::SetTo(value) => {
                self.0.set(*value);
            }
        }

        Ok(())
    }
}

#[test]
fn test_local_change() {
    let mut client = AperClient::<Counter>::new();
    let mut server = AperServer::<Counter>::new();

    let intent = CounterIntent::IncrementBy(5);
    let version = client.apply(&intent).unwrap();

    assert_eq!(1, version);
    assert_eq!(0, client.verified_client_version());
    assert_eq!(1, client.speculative_client_version());

    let mutations = server.apply(&intent).unwrap();

    client.mutate(&mutations, Some(version), 1);

    assert_eq!(1, client.verified_client_version());
    assert_eq!(1, client.speculative_client_version());

    let state = client.state();
    assert_eq!(5, state.get());
}

#[test]
fn test_remote_change() {
    let mut server = AperServer::<Counter>::new();

    let intent = CounterIntent::IncrementBy(5);
    let mutations = server.apply(&intent).unwrap();

    let mut client = AperClient::<Counter>::new();
    client.mutate(&mutations, None, 1);

    assert_eq!(0, client.verified_client_version());
    assert_eq!(0, client.speculative_client_version());

    let state = client.state();
    assert_eq!(5, state.get());
}

#[test]
fn test_speculative_change_remains() {
    // client1 makes a speculative change, then receives another change from the server.
    // client1 should apply both the speculative change and the server change.

    let mut server = AperServer::<Counter>::new();
    let mut client = AperClient::<Counter>::new();

    client.apply(&CounterIntent::IncrementBy(5)).unwrap();

    let mutations = server.apply(&CounterIntent::SetTo(10)).unwrap();

    client.mutate(&mutations, None, 1);

    assert_eq!(0, client.verified_client_version());
    assert_eq!(1, client.speculative_client_version());

    let state = client.state();
    assert_eq!(15, state.get());
}

#[test]
fn test_remote_changes_persist() {
    let mut server = AperServer::<Counter>::new();
    let mut client = AperClient::<Counter>::new();

    let intent = CounterIntent::IncrementBy(5);
    let mutations = server.apply(&intent).unwrap();
    client.mutate(&mutations, None, 1);

    let state = client.state();
    assert_eq!(5, state.get());

    let mutations = server.apply(&intent).unwrap();
    client.mutate(&mutations, None, 1);

    let state = client.state();
    assert_eq!(10, state.get());
}