VesselRs 0.1.0

Shared memory primitives for multi-agent orchestration
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190

//! Integration tests for thegent-shm
//!
//! These tests verify the integration between components.

use thegent_shm::domain::entities::{CircuitBreaker, CommandLock, HealthScore};
use thegent_shm::domain::value_objects::{CircuitState, LockStatus, XpLevel};
use thegent_shm::ports::driven::{CircuitBreakerPort, CommandCachePort};
use thegent_shm::adapters::inmemory::{InMemoryCircuitBreaker, InMemoryCommandCache};

#[test]
fn test_circuit_breaker_integration() {
    let mut breaker = InMemoryCircuitBreaker::new();

    // Record 4 failures - should not open yet
    for _ in 0..4 {
        breaker.record_failure("api.example.com").unwrap();
    }

    let cb = breaker.get_breaker("api.example.com").unwrap();
    assert_eq!(cb.state, CircuitState::Closed);
    assert_eq!(cb.failures, 4);

    // 5th failure should open the circuit
    breaker.record_failure("api.example.com").unwrap();

    let cb = breaker.get_breaker("api.example.com").unwrap();
    assert_eq!(cb.state, CircuitState::Open);
    assert_eq!(cb.failures, 5);

    // Record success - should close the circuit
    breaker.record_success("api.example.com").unwrap();

    let cb = breaker.get_breaker("api.example.com").unwrap();
    assert_eq!(cb.state, CircuitState::Closed);
    assert_eq!(cb.failures, 0);
}

#[test]
fn test_command_cache_integration() {
    let mut cache = InMemoryCommandCache::new();

    // Acquire lock
    cache.acquire_lock("cmd_hash_1", 1234).unwrap();

    let lock = cache.get_lock("cmd_hash_1").unwrap();
    assert_eq!(lock.pid, 1234);
    assert!(lock.is_locked());

    // Try to acquire again with different PID - should fail
    let result = cache.acquire_lock("cmd_hash_1", 5678);
    assert!(result.is_err());

    // Release lock
    cache.release_lock("cmd_hash_1", 1234).unwrap();

    let lock = cache.get_lock("cmd_hash_1").unwrap();
    assert!(!lock.is_locked());

    // Now different PID can acquire
    cache.acquire_lock("cmd_hash_1", 5678).unwrap();
    let lock = cache.get_lock("cmd_hash_1").unwrap();
    assert_eq!(lock.pid, 5678);
}

#[test]
fn test_multiple_commands() {
    let mut cache = InMemoryCommandCache::new();

    // Acquire multiple different locks
    cache.acquire_lock("cmd_a", 1001).unwrap();
    cache.acquire_lock("cmd_b", 1002).unwrap();
    cache.acquire_lock("cmd_c", 1003).unwrap();

    let locks = cache.list_locks();
    assert_eq!(locks.len(), 3);

    // Release one and verify others remain
    cache.release_lock("cmd_b", 1002).unwrap();

    let locks = cache.list_locks();
    assert_eq!(locks.len(), 3); // Still 3, but one is unlocked

    let lock_a = cache.get_lock("cmd_a").unwrap();
    let lock_b = cache.get_lock("cmd_b").unwrap();
    let lock_c = cache.get_lock("cmd_c").unwrap();

    assert!(lock_a.is_locked());
    assert!(!lock_b.is_locked());
    assert!(lock_c.is_locked());
}

#[test]
fn test_circuit_breaker_list() {
    let mut breaker = InMemoryCircuitBreaker::new();

    breaker.record_failure("service1").unwrap();
    breaker.record_failure("service2").unwrap();
    breaker.record_failure("service3").unwrap();

    let breakers = breaker.list_breakers();
    assert_eq!(breakers.len(), 3);

    // Verify all are tracked
    assert!(breakers.iter().all(|cb| cb.failures == 1));
}

#[test]
fn test_health_score_integration() {
    let mut score = HealthScore::new();

    score.set_component("cpu", 0.95);
    score.set_component("memory", 0.85);
    score.set_component("disk", 0.90);
    score.set_component("network", 0.90);

    assert!((score.overall() - 0.9).abs() < 0.01);
    assert!(score.is_healthy()); // Above 0.8 threshold

    // Add a failing component
    score.set_component("cpu", 0.1);

    assert!(score.is_degraded()); // Between 0.5 and 0.8
    assert!(!score.is_healthy());
}

#[test]
fn test_xp_level_integration() {
    let mut level = XpLevel::new();

    // Initial state
    assert_eq!(level.level, 1);
    assert_eq!(level.total_xp, 0);
    assert_eq!(level.xp_to_next_level(), 1000);

    // Add 500 XP - should be at 500/1000
    level.add_xp(500);
    assert_eq!(level.level, 1);
    assert_eq!(level.xp_to_next_level(), 500);

    // Add 500 more XP - should level up to 2
    level.add_xp(500);
    assert_eq!(level.level, 2);
    assert_eq!(level.xp_to_next_level(), 1000);

    // Add 1000 more XP - level 3, need 1000 to reach level 4
    // At 2000 XP: at threshold for level 3, need 1000 more
    level.add_xp(1000);
    assert_eq!(level.level, 3);
    assert_eq!(level.xp_to_next_level(), 1000);

    // Add 1000 more XP - level 4, need 1000 to reach level 5
    // At 3000 XP: at threshold for level 4, need 1000 more
    level.add_xp(1000);
    assert_eq!(level.level, 4);
    assert_eq!(level.xp_to_next_level(), 1000);

    // Add 500 XP - level 4, need 500 more to reach level 5
    // At 3500 XP: 500 into level 4, need 500 more
    level.add_xp(500);
    assert_eq!(level.level, 4);
    assert_eq!(level.xp_to_next_level(), 500);
}

#[test]
fn test_value_object_equality() {
    use thegent_shm::domain::value_objects::{CircuitState, LockStatus, XpLevel};

    // Test CircuitState equality
    let state1 = CircuitState::Closed;
    let state2 = CircuitState::Closed;
    let state3 = CircuitState::Open;

    assert_eq!(state1, state2);
    assert_ne!(state1, state3);

    // Test LockStatus equality
    let status1 = LockStatus::Locked;
    let status2 = LockStatus::Locked;
    let status3 = LockStatus::Unlocked;

    assert_eq!(status1, status2);
    assert_ne!(status1, status3);

    // Test XpLevel equality (same values)
    let level1 = XpLevel::new();
    let level2 = XpLevel::new();

    assert_eq!(level1.level, level2.level);
    assert_eq!(level1.total_xp, level2.total_xp);
}