force 0.4.0

Production-ready Salesforce Platform API client with REST and Bulk API 2.0 support
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

use std::fmt::Debug;

pub trait Must<T> {
    fn must(self) -> T;
}

impl<T, E: Debug> Must<T> for std::result::Result<T, E> {
    fn must(self) -> T {
        match self {
            Ok(value) => value,
            Err(error) => panic!("unexpected Err: {error:?}"),
        }
    }
}

impl<T> Must<T> for Option<T> {
    fn must(self) -> T {
        match self {
            Some(value) => value,
            None => panic!("unexpected None"),
        }
    }
}

pub trait MustMsg<T> {
    fn must_msg(self, message: &str) -> T;
}

impl<T, E: Debug> MustMsg<T> for std::result::Result<T, E> {
    fn must_msg(self, message: &str) -> T {
        match self {
            Ok(value) => value,
            Err(error) => panic!("{message}: {error:?}"),
        }
    }
}

impl<T> MustMsg<T> for Option<T> {
    fn must_msg(self, message: &str) -> T {
        match self {
            Some(value) => value,
            None => panic!("{message}"),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_must_result_ok() {
        let result: Result<i32, &str> = Ok(42);
        assert_eq!(result.must(), 42);
    }

    #[test]
    #[should_panic(expected = "unexpected Err: \"error message\"")]
    fn test_must_result_err() {
        let result: Result<i32, &str> = Err("error message");
        let _ = result.must();
    }

    #[test]
    fn test_must_option_some() {
        let option: Option<i32> = Some(42);
        assert_eq!(option.must(), 42);
    }

    #[test]
    #[should_panic(expected = "unexpected None")]
    fn test_must_option_none() {
        let option: Option<i32> = None;
        let _ = option.must();
    }

    #[test]
    fn test_must_msg_result_ok() {
        let result: Result<i32, &str> = Ok(42);
        assert_eq!(result.must_msg("Custom panic message"), 42);
    }

    #[test]
    #[should_panic(expected = "Custom panic message: \"error message\"")]
    fn test_must_msg_result_err() {
        let result: Result<i32, &str> = Err("error message");
        let _ = result.must_msg("Custom panic message");
    }

    #[test]
    fn test_must_msg_option_some() {
        let option: Option<i32> = Some(42);
        assert_eq!(option.must_msg("Custom panic message"), 42);
    }

    #[test]
    #[should_panic(expected = "Custom panic message")]
    fn test_must_msg_option_none() {
        let option: Option<i32> = None;
        let _ = option.must_msg("Custom panic message");
    }
}