jsoncall 0.0.3

A simple asynchronous JSON-RPC 2.0 library leveraging Rust's type system
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

use std::{
    backtrace::BacktraceStatus,
    fmt::{self, Display},
};

use jsoncall::{Error, ErrorCode, SessionError};

#[derive(Debug)]
struct DetailedError;

impl std::error::Error for DetailedError {}

impl Display for DetailedError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "DetailedError")
    }
}

#[test]
fn expose_internals_false() {
    let e = Error::from(DetailedError);
    let eo = e.to_error_object(false);
    assert_eq!(eo.code, ErrorCode::INTERNAL_ERROR);
    assert_eq!(eo.message, ErrorCode::INTERNAL_ERROR.message());
    assert_eq!(eo.data, None);
}

#[test]
fn expose_internals_false_session_error() {
    let e = Error::from(DetailedError);
    let eo = e.to_error_object(false);
    let se = SessionError::from(eo);
    let se_str = se.to_string();

    assert!(!se_str.contains("DetailedError"));
}

#[test]
fn expose_internals_true() {
    let e = Error::from(DetailedError);
    let eo = e.to_error_object(true);
    assert_eq!(eo.code, ErrorCode::INTERNAL_ERROR);
    assert_eq!(eo.message, "DetailedError");
    assert!(eo.data.is_some());
    let data = eo.data.unwrap();
    assert_eq!(data["source"], "DetailedError", "source");
}

#[test]
fn expose_internals_true_session_error() {
    let e = Error::from(DetailedError);
    let eo = e.to_error_object(true);
    let se = SessionError::from(eo);
    let se_str = se.to_string();
    assert!(se_str.contains("DetailedError"), "SessionError = {se_str}");
    if e.backtrace().status() == BacktraceStatus::Captured {
        assert!(
            se_str.contains(&format!("{:#?}", e.backtrace())),
            "SessionError = {se_str}"
        );
    }
}