quint-connect 0.1.2

A model-based testing framework that connects Quint specifications with Rust 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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use serde::Deserialize;

#[derive(Eq, PartialEq, Deserialize, Default, Copy, Clone, Debug)]
#[serde(tag = "tag")]
pub enum Stage {
    #[default]
    Working,
    Prepared,
    Committed,
    Aborted,
}

#[derive(Eq, PartialEq, Ord, PartialOrd, Copy, Clone, Debug)]
pub enum Message {
    Prepare,
    Prepared,
    Commit,
    Abort,
}

pub enum Node {
    Coordinator(Coordinator),
    Participant(Participant),
}

impl Node {
    pub fn stage(&self) -> Stage {
        match self {
            Node::Coordinator(coord) => coord.stage,
            Node::Participant(part) => part.stage,
        }
    }

    pub fn timeout(&mut self) -> Option<Message> {
        match self {
            Node::Coordinator(coord) => coord.timeout(),
            Node::Participant(part) => part.timeout(),
        }
    }

    pub fn receive(&mut self, msg: Message) -> Option<Message> {
        match self {
            Node::Coordinator(coord) => coord.receive(msg),
            Node::Participant(part) => part.receive(msg),
        }
    }
}

pub struct Coordinator {
    stage: Stage,
    quorum: usize,
    prepared: usize,
}

impl Coordinator {
    pub fn new(quorum: usize) -> Self {
        Self {
            stage: Stage::Working,
            prepared: 0,
            quorum,
        }
    }

    pub fn start(&self) -> Message {
        Message::Prepare
    }

    pub fn timeout(&mut self) -> Option<Message> {
        match self.stage {
            Stage::Working => {
                self.stage = Stage::Aborted;
                Some(Message::Abort)
            }
            _ => None,
        }
    }

    pub fn receive(&mut self, msg: Message) -> Option<Message> {
        match (self.stage, msg) {
            (Stage::Working, Message::Prepared) => {
                self.prepared += 1;
                if self.prepared == self.quorum {
                    self.stage = Stage::Committed;
                    return Some(Message::Commit);
                }
                None
            }
            _ => None,
        }
    }
}

#[derive(Default)]
pub struct Participant {
    stage: Stage,
}

impl Participant {
    pub fn timeout(&mut self) -> Option<Message> {
        match self.stage {
            Stage::Working => {
                self.stage = Stage::Aborted;
                None
            }
            _ => None,
        }
    }

    pub fn receive(&mut self, msg: Message) -> Option<Message> {
        match (self.stage, msg) {
            (Stage::Working, Message::Prepare) => {
                self.stage = Stage::Prepared;
                Some(Message::Prepared)
            }
            (_, Message::Abort) => {
                self.stage = Stage::Aborted;
                None
            }
            (_, Message::Commit) => {
                self.stage = Stage::Committed;
                None
            }
            _ => None,
        }
    }
}