okerr 1.0.2

Ergonomic result / error handling helpers built on anyhow and thiserror.
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

//! Tests for ensure! macro (re-export from anyhow)

use okerr::{Result, ensure};

#[test]
fn ensure_macro_with_true_condition() {
    fn check_positive(n: i32) -> Result<i32> {
        ensure!(n > 0, "number must be positive");
        Ok(n)
    }

    let result = check_positive(42);
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), 42);
}

#[test]
fn ensure_macro_with_false_condition() {
    fn check_positive(n: i32) -> Result<i32> {
        ensure!(n > 0, "number must be positive");
        Ok(n)
    }

    let result = check_positive(-5);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().to_string(), "number must be positive");
}

#[test]
fn ensure_macro_with_formatted_message() {
    fn validate_range(n: i32, min: i32, max: i32) -> Result<i32> {
        ensure!(
            n >= min && n <= max,
            "value {} is out of range [{}, {}]",
            n,
            min,
            max
        );
        Ok(n)
    }

    let result = validate_range(50, 0, 100);
    assert!(result.is_ok());

    let result = validate_range(150, 0, 100);
    assert!(result.is_err());
    assert_eq!(
        result.unwrap_err().to_string(),
        "value 150 is out of range [0, 100]"
    );
}

#[test]
fn ensure_macro_multiple_conditions() {
    fn validate_string(s: &str) -> Result<String> {
        ensure!(!s.is_empty(), "string cannot be empty");
        ensure!(s.len() <= 10, "string too long: {} chars", s.len());
        Ok(s.to_uppercase())
    }

    let result = validate_string("hello");
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), "HELLO");

    let result = validate_string("");
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().to_string(), "string cannot be empty");

    let result = validate_string("this is too long");
    assert!(result.is_err());
    assert!(result.unwrap_err().to_string().contains("string too long"));
}

#[test]
fn ensure_macro_in_loop() {
    fn all_positive(numbers: &[i32]) -> Result<i32> {
        let mut sum = 0;
        for &num in numbers {
            ensure!(num > 0, "found negative or zero number: {}", num);
            sum += num;
        }
        Ok(sum)
    }

    let result = all_positive(&[1, 2, 3, 4, 5]);
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), 15);

    let result = all_positive(&[1, 2, -3, 4]);
    assert!(result.is_err());
    assert!(
        result
            .unwrap_err()
            .to_string()
            .contains("found negative or zero number: -3")
    );
}

#[test]
fn ensure_macro_with_complex_condition() {
    fn validate_user(name: &str, age: i32) -> Result<()> {
        ensure!(
            !name.is_empty() && age >= 18,
            "invalid user: name='{}', age={}",
            name,
            age
        );
        Ok(())
    }

    let result = validate_user("Alice", 25);
    assert!(result.is_ok());

    let result = validate_user("", 25);
    assert!(result.is_err());

    let result = validate_user("Bob", 15);
    assert!(result.is_err());
}

#[test]
fn ensure_macro_early_return() {
    fn process(value: i32) -> Result<i32> {
        ensure!(value != 0, "value cannot be zero");

        // This code should not execute if ensure! fails
        let result = 100 / value;
        Ok(result)
    }

    let result = process(10);
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), 10);

    let result = process(0);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().to_string(), "value cannot be zero");
}

#[test]
fn ensure_macro_is_from_anyhow() {
    // Verify that ensure! is the anyhow re-export by checking behavior
    fn test() -> Result<()> {
        ensure!(true, "should not fail");
        ensure!(1 + 1 == 2, "math should work");
        Ok(())
    }

    let result = test();
    assert!(result.is_ok());
}