apr-cli 0.4.13

CLI tool for APR model inspection, debugging, and operations
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
146
147
148


#[test]
fn test_circuit_breaker_all_states_multiple() {
    let config = CircuitBreakerConfig {
        failure_threshold: 2,
        ..Default::default()
    };
    let breaker = CircuitBreaker::new(config);

    let n1 = NodeId("n1".to_string());
    let n2 = NodeId("n2".to_string());

    // n1: make it open
    breaker.record_failure(&n1);
    breaker.record_failure(&n1);

    // n2: keep it closed
    breaker.record_success(&n2);

    let states = breaker.all_states();
    assert_eq!(states.len(), 2);

    let n1_state = states.iter().find(|(id, _)| *id == n1).map(|(_, s)| *s);
    let n2_state = states.iter().find(|(id, _)| *id == n2).map(|(_, s)| *s);

    assert_eq!(n1_state, Some(CircuitState::Open));
    assert_eq!(n2_state, Some(CircuitState::Closed));
}

#[test]
fn test_circuit_breaker_unknown_node_defaults_closed() {
    let breaker = CircuitBreaker::default();
    let unknown = NodeId("unknown".to_string());

    assert_eq!(breaker.state(&unknown), CircuitState::Closed);
    assert!(!breaker.is_open(&unknown));
}

#[test]
fn test_circuit_breaker_record_success_in_open_resets() {
    let config = CircuitBreakerConfig {
        failure_threshold: 2,
        ..Default::default()
    };
    let breaker = CircuitBreaker::new(config);
    let node = NodeId("node".to_string());

    // Open circuit
    breaker.record_failure(&node);
    breaker.record_failure(&node);
    assert_eq!(breaker.state(&node), CircuitState::Open);

    // Record success while open (edge case)
    breaker.record_success(&node);
    // Should reset to closed
    assert_eq!(breaker.state(&node), CircuitState::Closed);
}

#[test]
fn test_circuit_breaker_failure_in_half_open_reopens() {
    let config = CircuitBreakerConfig {
        failure_threshold: 2,
        half_open_successes: 3,
        reset_timeout: Duration::from_millis(10),
    };
    let breaker = CircuitBreaker::new(config);
    let node = NodeId("node".to_string());

    // Open circuit
    breaker.record_failure(&node);
    breaker.record_failure(&node);
    assert_eq!(breaker.state(&node), CircuitState::Open);

    // Wait for reset
    std::thread::sleep(Duration::from_millis(20));

    // Transition to half-open
    assert!(!breaker.is_open(&node));
    assert_eq!(breaker.state(&node), CircuitState::HalfOpen);

    // Failure in half-open -> back to open
    breaker.record_failure(&node);
    assert_eq!(breaker.state(&node), CircuitState::Open);
}

#[test]
fn test_circuit_breaker_failure_while_already_open() {
    let config = CircuitBreakerConfig {
        failure_threshold: 2,
        ..Default::default()
    };
    let breaker = CircuitBreaker::new(config);
    let node = NodeId("node".to_string());

    // Open circuit
    breaker.record_failure(&node);
    breaker.record_failure(&node);
    assert_eq!(breaker.state(&node), CircuitState::Open);

    // Additional failure while open should not panic
    breaker.record_failure(&node);
    assert_eq!(breaker.state(&node), CircuitState::Open);
}

#[test]
fn test_circuit_breaker_is_open_before_timeout() {
    let config = CircuitBreakerConfig {
        failure_threshold: 2,
        reset_timeout: Duration::from_secs(60), // Long timeout
        ..Default::default()
    };
    let breaker = CircuitBreaker::new(config);
    let node = NodeId("node".to_string());

    breaker.record_failure(&node);
    breaker.record_failure(&node);

    // Still open (timeout hasn't passed)
    assert!(breaker.is_open(&node));
}

#[test]
fn test_circuit_breaker_half_open_partial_success() {
    let config = CircuitBreakerConfig {
        failure_threshold: 2,
        half_open_successes: 3,
        reset_timeout: Duration::from_millis(10),
    };
    let breaker = CircuitBreaker::new(config);
    let node = NodeId("node".to_string());

    // Open circuit
    breaker.record_failure(&node);
    breaker.record_failure(&node);
    std::thread::sleep(Duration::from_millis(20));

    // Transition to half-open
    assert!(!breaker.is_open(&node));

    // 2 successes (need 3)
    breaker.record_success(&node);
    breaker.record_success(&node);
    assert_eq!(breaker.state(&node), CircuitState::HalfOpen);

    // 3rd success -> closed
    breaker.record_success(&node);
    assert_eq!(breaker.state(&node), CircuitState::Closed);
}