test-tube 0.7.0

library for building integration testing environments for cosmos-sdk chains in Rust
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

use cosmrs::rpc::error::Error as TendermintRpcError;
use cosmrs::tendermint::Error as TendermintError;
use cosmrs::ErrorReport;
use std::str::Utf8Error;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum RunnerError {
    #[error("unable to encode request")]
    EncodeError(#[from] EncodeError),

    #[error("unable to decode response")]
    DecodeError(#[from] DecodeError),

    #[error("query error: {}", .msg)]
    QueryError { msg: String },

    #[error("execute error: {}", .msg)]
    ExecuteError { msg: String },

    #[error("{0}")]
    GenericError(String),

    #[error("{0}")]
    ErrorReport(#[from] ErrorReport),

    #[error("{0}")]
    Tendermint(#[from] TendermintError),

    #[error("{0}")]
    TendermintRpc(#[from] TendermintRpcError),
}

impl PartialEq for RunnerError {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (RunnerError::EncodeError(a), RunnerError::EncodeError(b)) => a == b,
            (RunnerError::DecodeError(a), RunnerError::DecodeError(b)) => a == b,
            (RunnerError::QueryError { msg: a }, RunnerError::QueryError { msg: b }) => a == b,
            (RunnerError::ExecuteError { msg: a }, RunnerError::ExecuteError { msg: b }) => a == b,
            (RunnerError::ErrorReport(a), RunnerError::ErrorReport(b)) => {
                a.to_string() == b.to_string()
            }
            (RunnerError::Tendermint(a), RunnerError::Tendermint(b)) => {
                a.to_string() == b.to_string()
            }
            (RunnerError::TendermintRpc(a), RunnerError::TendermintRpc(b)) => a.0 == b.0,
            _ => false,
        }
    }
}

#[derive(Error, Debug)]
pub enum DecodeError {
    #[error("invalid utf8 bytes")]
    Utf8Error(#[from] Utf8Error),

    #[error("invalid protobuf")]
    ProtoDecodeError(#[from] prost::DecodeError),

    #[error("invalid json")]
    JsonDecodeError(#[from] serde_json::Error),

    #[error("invalid base64")]
    Base64DecodeError(#[from] base64::DecodeError),

    #[error("invalid signing key")]
    SigningKeyDecodeError { msg: String },
}

impl PartialEq for DecodeError {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (DecodeError::Utf8Error(a), DecodeError::Utf8Error(b)) => a == b,
            (DecodeError::ProtoDecodeError(a), DecodeError::ProtoDecodeError(b)) => a == b,
            (DecodeError::JsonDecodeError(a), DecodeError::JsonDecodeError(b)) => {
                a.to_string() == b.to_string()
            }
            (DecodeError::Base64DecodeError(a), DecodeError::Base64DecodeError(b)) => a == b,
            (
                DecodeError::SigningKeyDecodeError { msg: a },
                DecodeError::SigningKeyDecodeError { msg: b },
            ) => a == b,
            _ => false,
        }
    }
}

#[derive(Error, Debug)]
pub enum EncodeError {
    #[error("invalid protobuf")]
    ProtoEncodeError(#[from] prost::EncodeError),

    #[error("unable to encode json")]
    JsonEncodeError(#[from] serde_json::Error),
}

impl EncodeError {
    pub fn from_proto_error_report(err: cosmrs::ErrorReport) -> Self {
        match err.downcast::<prost::EncodeError>() {
            Ok(encode_err) => EncodeError::ProtoEncodeError(encode_err),
            Err(e) => panic!("expect `prost::EncodeError` but got {:?}", e),
        }
    }
}

impl PartialEq for EncodeError {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (EncodeError::ProtoEncodeError(a), EncodeError::ProtoEncodeError(b)) => a == b,
            (EncodeError::JsonEncodeError(a), EncodeError::JsonEncodeError(b)) => {
                a.to_string() == b.to_string()
            }
            _ => false,
        }
    }
}