d-engine-proto 0.2.3

gRPC protocol definitions - for building non-Rust d-engine clients
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use crate::common::LogId;
use crate::server::replication::AppendEntriesResponse;

#[test]
fn test_append_entries_response_success() {
    let log_id = LogId { term: 5, index: 10 };
    let response = AppendEntriesResponse::success(1, 5, Some(log_id));

    assert_eq!(response.node_id, 1);
    assert_eq!(response.term, 5);
    assert!(response.is_success());
    assert!(!response.is_conflict());
    assert!(!response.is_higher_term());

    match &response.result {
        Some(crate::server::replication::append_entries_response::Result::Success(success)) => {
            assert_eq!(success.last_match, Some(log_id));
        }
        _ => panic!("Expected success result"),
    }
}

#[test]
fn test_append_entries_response_success_without_log_id() {
    let response = AppendEntriesResponse::success(2, 3, None);

    assert_eq!(response.node_id, 2);
    assert_eq!(response.term, 3);
    assert!(response.is_success());
    assert!(!response.is_conflict());
    assert!(!response.is_higher_term());

    match &response.result {
        Some(crate::server::replication::append_entries_response::Result::Success(success)) => {
            assert_eq!(success.last_match, None);
        }
        _ => panic!("Expected success result"),
    }
}

#[test]
fn test_append_entries_response_conflict() {
    let response = AppendEntriesResponse::conflict(3, 6, Some(4), Some(8));

    assert_eq!(response.node_id, 3);
    assert_eq!(response.term, 6);
    assert!(!response.is_success());
    assert!(response.is_conflict());
    assert!(!response.is_higher_term());

    match &response.result {
        Some(crate::server::replication::append_entries_response::Result::Conflict(conflict)) => {
            assert_eq!(conflict.conflict_term, Some(4));
            assert_eq!(conflict.conflict_index, Some(8));
        }
        _ => panic!("Expected conflict result"),
    }
}

#[test]
fn test_append_entries_response_conflict_without_details() {
    let response = AppendEntriesResponse::conflict(4, 7, None, None);

    assert_eq!(response.node_id, 4);
    assert_eq!(response.term, 7);
    assert!(!response.is_success());
    assert!(response.is_conflict());
    assert!(!response.is_higher_term());

    match &response.result {
        Some(crate::server::replication::append_entries_response::Result::Conflict(conflict)) => {
            assert_eq!(conflict.conflict_term, None);
            assert_eq!(conflict.conflict_index, None);
        }
        _ => panic!("Expected conflict result"),
    }
}

#[test]
fn test_append_entries_response_higher_term() {
    let response = AppendEntriesResponse::higher_term(5, 10);

    assert_eq!(response.node_id, 5);
    assert_eq!(response.term, 10);
    assert!(!response.is_success());
    assert!(!response.is_conflict());
    assert!(response.is_higher_term());

    match &response.result {
        Some(crate::server::replication::append_entries_response::Result::HigherTerm(term)) => {
            assert_eq!(*term, 10);
        }
        _ => panic!("Expected higher term result"),
    }
}

#[test]
fn test_append_entries_response_mutually_exclusive() {
    // Test success response
    let success = AppendEntriesResponse::success(1, 1, None);
    assert!(success.is_success());
    assert!(!success.is_conflict());
    assert!(!success.is_higher_term());

    // Test conflict response
    let conflict = AppendEntriesResponse::conflict(2, 2, None, None);
    assert!(!conflict.is_success());
    assert!(conflict.is_conflict());
    assert!(!conflict.is_higher_term());

    // Test higher term response
    let higher = AppendEntriesResponse::higher_term(3, 3);
    assert!(!higher.is_success());
    assert!(!higher.is_conflict());
    assert!(higher.is_higher_term());
}

#[test]
fn test_append_entries_response_large_indices() {
    let log_id = LogId {
        term: u64::MAX,
        index: u64::MAX,
    };
    let response = AppendEntriesResponse::success(u32::MAX, u64::MAX, Some(log_id));

    assert_eq!(response.node_id, u32::MAX);
    assert_eq!(response.term, u64::MAX);

    match &response.result {
        Some(crate::server::replication::append_entries_response::Result::Success(success)) => {
            assert_eq!(success.last_match.unwrap().term, u64::MAX);
            assert_eq!(success.last_match.unwrap().index, u64::MAX);
        }
        _ => panic!("Expected success result"),
    }
}

#[test]
fn test_append_entries_response_zero_values() {
    let response = AppendEntriesResponse::success(0, 0, None);

    assert_eq!(response.node_id, 0);
    assert_eq!(response.term, 0);
    assert!(response.is_success());
}