ash-flare 2.3.3

Fault-tolerant supervision trees for Rust with distributed capabilities inspired by Erlang/OTP
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

use ash_flare::SupervisorError;

#[test]
fn test_supervisor_error_no_children() {
    let err = SupervisorError::NoChildren("test-supervisor".to_string());
    let msg = format!("{}", err);
    assert!(msg.contains("test-supervisor"));
    assert!(msg.contains("has no children"));
}

#[test]
fn test_supervisor_error_all_children_failed() {
    let err = SupervisorError::AllChildrenFailed("main-supervisor".to_string());
    let msg = format!("{}", err);
    assert!(msg.contains("main-supervisor"));
    assert!(msg.contains("all children failed"));
    assert!(msg.contains("restart intensity limit exceeded"));
}

#[test]
fn test_supervisor_error_shutting_down() {
    let err = SupervisorError::ShuttingDown("service-supervisor".to_string());
    let msg = format!("{}", err);
    assert!(msg.contains("service-supervisor"));
    assert!(msg.contains("shutting down"));
    assert!(msg.contains("operation not permitted"));
}

#[test]
fn test_supervisor_error_child_already_exists() {
    let err = SupervisorError::ChildAlreadyExists("worker-1".to_string());
    let msg = format!("{}", err);
    assert!(msg.contains("worker-1"));
    assert!(msg.contains("already exists"));
    assert!(msg.contains("unique identifier"));
}

#[test]
fn test_supervisor_error_child_not_found() {
    let err = SupervisorError::ChildNotFound("worker-2".to_string());
    let msg = format!("{}", err);
    assert!(msg.contains("worker-2"));
    assert!(msg.contains("not found"));
    assert!(msg.contains("may have already terminated"));
}

#[test]
fn test_supervisor_error_debug() {
    let err = SupervisorError::NoChildren("test".to_string());
    let debug_str = format!("{:?}", err);
    assert!(debug_str.contains("NoChildren"));
    assert!(debug_str.contains("test"));
}

#[test]
fn test_supervisor_error_is_error() {
    let err = SupervisorError::ShuttingDown("test".to_string());
    // Verify it implements std::error::Error
    let _err_ref: &dyn std::error::Error = &err;
}

#[test]
fn test_all_error_variants() {
    let errors = vec![
        SupervisorError::NoChildren("sup1".to_string()),
        SupervisorError::AllChildrenFailed("sup2".to_string()),
        SupervisorError::ShuttingDown("sup3".to_string()),
        SupervisorError::ChildAlreadyExists("child1".to_string()),
        SupervisorError::ChildNotFound("child2".to_string()),
    ];

    for err in errors {
        let msg = format!("{}", err);
        let debug = format!("{:?}", err);
        assert!(!msg.is_empty());
        assert!(!debug.is_empty());
    }
}

#[test]
fn test_error_display_formatting() {
    let err = SupervisorError::NoChildren("my-supervisor".to_string());
    let display = err.to_string();
    let formatted = format!("{}", err);
    assert_eq!(display, formatted);
}

#[test]
fn test_error_with_empty_name() {
    let err = SupervisorError::NoChildren("".to_string());
    let msg = format!("{}", err);
    assert!(msg.contains("''"));
}

#[test]
fn test_error_with_special_characters() {
    let err = SupervisorError::ChildNotFound("worker-123-!@#$".to_string());
    let msg = format!("{}", err);
    assert!(msg.contains("worker-123-!@#$"));
}

#[test]
fn test_error_source() {
    let err = SupervisorError::ShuttingDown("test".to_string());
    // std::error::Error::source() should return None for these errors
    assert!(std::error::Error::source(&err).is_none());
}