ibc_testkit/fixtures/core/client/
mod.rs

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
#[cfg(feature = "serde")]
mod msg_create_client;
#[cfg(feature = "serde")]
mod msg_update_client;
mod msg_upgrade_client;

#[cfg(feature = "serde")]
pub use self::msg_create_client::*;
#[cfg(feature = "serde")]
pub use self::msg_update_client::*;
pub use self::msg_upgrade_client::*;

#[cfg(test)]
mod tests {
    use core::str::FromStr;

    use ibc::core::client::types::events::*;
    use ibc::core::client::types::Height;
    use ibc::core::host::types::identifiers::*;
    use ibc::primitives::prelude::*;
    use ibc::primitives::ToVec;
    use ibc_proto::google::protobuf::Any;
    use tendermint::abci::Event as AbciEvent;

    use crate::fixtures::clients::mock::dummy_new_mock_header;

    #[test]
    fn ibc_to_abci_client_events() {
        struct Test {
            event_kind: &'static str,
            event: AbciEvent,
            expected_keys: Vec<&'static str>,
            expected_values: Vec<&'static str>,
        }

        let client_type = ClientType::from_str("07-tendermint")
            .expect("never fails because it's a valid client type");
        let client_id = client_type.build_client_id(0);
        let consensus_height = Height::new(0, 5).unwrap();
        let consensus_heights = vec![Height::new(0, 5).unwrap(), Height::new(0, 7).unwrap()];
        let header: Any = dummy_new_mock_header(5).into();
        let expected_keys = vec![
            "client_id",
            "client_type",
            "consensus_height",
            "consensus_heights",
            "header",
        ];

        let expected_values = vec![
            "07-tendermint-0",
            "07-tendermint",
            "0-5",
            "0-5,0-7",
            "0a102f6962632e6d6f636b2e486561646572120e0a021005108080889ebdc8819b17",
        ];

        let tests: Vec<Test> = vec![
            Test {
                event_kind: CREATE_CLIENT_EVENT,
                event: CreateClient::new(client_id.clone(), client_type.clone(), consensus_height)
                    .into(),
                expected_keys: expected_keys[0..3].to_vec(),
                expected_values: expected_values[0..3].to_vec(),
            },
            Test {
                event_kind: UPDATE_CLIENT_EVENT,
                event: UpdateClient::new(
                    client_id.clone(),
                    client_type.clone(),
                    consensus_height,
                    consensus_heights,
                    header.to_vec(),
                )
                .into(),
                expected_keys: expected_keys.clone(),
                expected_values: expected_values.clone(),
            },
            Test {
                event_kind: UPGRADE_CLIENT_EVENT,
                event: UpgradeClient::new(client_id.clone(), client_type.clone(), consensus_height)
                    .into(),
                expected_keys: expected_keys[0..3].to_vec(),
                expected_values: expected_values[0..3].to_vec(),
            },
            Test {
                event_kind: CLIENT_MISBEHAVIOUR_EVENT,
                event: ClientMisbehaviour::new(client_id, client_type).into(),
                expected_keys: expected_keys[0..2].to_vec(),
                expected_values: expected_values[0..2].to_vec(),
            },
        ];

        for t in tests {
            assert_eq!(t.event.kind, t.event_kind);
            assert_eq!(t.expected_keys.len(), t.event.attributes.len());
            for (i, e) in t.event.attributes.iter().enumerate() {
                assert_eq!(
                    e.key_str().unwrap(),
                    t.expected_keys[i],
                    "key mismatch for {:?}",
                    t.event_kind
                );
            }
            for (i, e) in t.event.attributes.iter().enumerate() {
                assert_eq!(
                    e.value_str().unwrap(),
                    t.expected_values[i],
                    "value mismatch for {:?}",
                    t.event_kind
                );
            }
        }
    }
}