bitwarden-error 3.0.0

Internal crate for the bitwarden crate. Do not use.
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

#![allow(missing_docs)]

use std::fmt::Display;

use bitwarden_error::{bitwarden_error, flat_error::FlatError};
#[cfg(feature = "wasm")]
use wasm_bindgen_test::*;

#[test]
fn variant_for_basic_enum() {
    #[bitwarden_error(flat)]
    enum SimpleError {
        Foo,
        Bar,
        Baz,
    }

    impl Display for SimpleError {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            write!(f, "This is an error")
        }
    }

    let foo = SimpleError::Foo;
    let bar = SimpleError::Bar;
    let baz = SimpleError::Baz;

    assert_eq!(foo.error_variant(), "Foo");
    assert_eq!(bar.error_variant(), "Bar");
    assert_eq!(baz.error_variant(), "Baz");
}

#[test]
fn variant_for_enum_with_fields() {
    #[allow(dead_code)]
    #[bitwarden_error(flat)]
    enum ComplexError {
        Foo(String),
        Bar { x: i32, y: i32 },
        Baz(bool, bool),
    }
    impl Display for ComplexError {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            write!(f, "This is an error")
        }
    }

    let foo = ComplexError::Foo("hello".to_string());
    let bar = ComplexError::Bar { x: 1, y: 2 };
    let baz = ComplexError::Baz(true, true);

    assert_eq!(foo.error_variant(), "Foo");
    assert_eq!(bar.error_variant(), "Bar");
    assert_eq!(baz.error_variant(), "Baz");
}

#[test]
#[cfg(feature = "wasm")]
fn variant_names_for_enum() {
    #[allow(dead_code)]
    #[bitwarden_error(flat)]
    enum SimpleEnum {
        Foo,
        Bar,
        Baz,
    }
    impl Display for SimpleEnum {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            write!(f, "This is an error")
        }
    }

    // TODO: Not sure how to test this yet
    // let types = TS_TYPES_SimpleError;
    // assert_eq!(
    //     types,
    //     r#"
    //         export const TS_TYPES_SimpleError = "<TODO>";
    //     "#
    // );
}

#[wasm_bindgen_test]
#[cfg(feature = "wasm")]
#[allow(dead_code)] // Not actually dead, but rust-analyzer doesn't understand `wasm_bindgen_test`
fn converts_to_js_error() {
    use bitwarden_error::wasm::SdkJsError;
    use wasm_bindgen::JsValue;

    #[bitwarden_error(flat)]
    enum FlatEnum {
        Foo,
        Bar,
        Baz,
    }
    impl Display for FlatEnum {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            write!(f, "This is an error")
        }
    }

    let simple = FlatEnum::Baz;
    let js_value: JsValue = simple.into();

    let js_error = SdkJsError::from(js_value);
    assert_eq!(js_error.name(), "FlatEnum");
    assert_eq!(js_error.message(), "This is an error");
    assert_eq!(js_error.variant(), "Baz");
}

#[wasm_bindgen_test]
#[cfg(feature = "wasm")]
#[allow(dead_code)] // Not actually dead, but rust-analyzer doesn't understand `wasm_bindgen_test`
fn outputs_different_name_when_given_export_as() {
    use bitwarden_error::wasm::SdkJsError;
    use wasm_bindgen::JsValue;

    #[bitwarden_error(flat, export_as = "SomeOtherEnum")]
    enum FlatEnum {
        Foo,
        Bar,
        Baz,
    }
    impl Display for FlatEnum {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            write!(f, "This is an error")
        }
    }

    let simple = FlatEnum::Baz;
    let js_value: JsValue = simple.into();

    let js_error = SdkJsError::from(js_value);
    assert_eq!(js_error.name(), "SomeOtherEnum");
    assert_eq!(js_error.message(), "This is an error");
    assert_eq!(js_error.variant(), "Baz");
}