ibc-test-framework 0.32.2

Framework for writing integration tests for IBC relayers 
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

use std::str::FromStr;
use std::thread;

use crate::bootstrap::consumer::bootstrap_consumer_node;
use crate::bootstrap::single::bootstrap_single_node;
use crate::chain::builder::ChainBuilder;
use crate::chain::chain_type::ChainType;
use crate::chain::ext::bootstrap::ChainBootstrapMethodsExt;
use crate::error::Error;
use crate::framework::base::{run_basic_test, BasicTest, HasOverrides, TestConfigOverride};
use crate::framework::binary::node::{NodeConfigOverride, NodeGenesisOverride};
use crate::prelude::FullNode;
use crate::types::config::TestConfig;

/**
Runs a test case that implements [`InterchainSecurityChainTest`].
*/
pub fn run_binary_interchain_security_node_test<Test, Overrides>(test: &Test) -> Result<(), Error>
where
    Test: InterchainSecurityChainTest,
    Test: HasOverrides<Overrides = Overrides>,
    Overrides: NodeConfigOverride + NodeGenesisOverride + TestConfigOverride,
{
    run_basic_test(&RunInterchainSecurityChainTest { test })
}
pub trait InterchainSecurityChainTest {
    /// Test runner
    fn run(&self, config: &TestConfig, node_a: FullNode, node_b: FullNode) -> Result<(), Error>;
}

/**
 A wrapper type that lifts a test case that implements [`InterchainSecurityChainTest`]
 into a test case the implements [`BasicTest`].
*/
pub struct RunInterchainSecurityChainTest<'a, Test> {
    /// Inner test
    pub test: &'a Test,
}

impl<'a, Test> RunInterchainSecurityChainTest<'a, Test>
where
    Test: InterchainSecurityChainTest,
{
    /// Create a new [`InterchainSecurityChainTest`]
    pub fn new(test: &'a Test) -> Self {
        Self { test }
    }
}

impl<Test, Overrides> BasicTest for RunInterchainSecurityChainTest<'_, Test>
where
    Test: InterchainSecurityChainTest,
    Test: HasOverrides<Overrides = Overrides>,
    Overrides: NodeConfigOverride + NodeGenesisOverride,
{
    fn run(&self, config: &TestConfig, builder: &ChainBuilder) -> Result<(), Error> {
        // Bootstrap provider
        let node_a = bootstrap_single_node(
            builder,
            "provider",
            false,
            |config| self.test.get_overrides().modify_node_config(config),
            |genesis| self.test.get_overrides().modify_genesis_file(genesis),
            0,
        )?;
        let provider_native_token = builder.native_tokens[0].clone();
        let provider_fee = format!("381000000{provider_native_token}");

        // Get consumer chain id
        let chain_type = ChainType::from_str(&builder.command_paths[1])?;
        let chain_id = chain_type.chain_id("consumer", false);

        let consumer_id = node_a
            .chain_driver
            .create_permisionless_consumer(chain_id.as_str(), &provider_fee)?;

        thread::sleep(std::time::Duration::from_secs(3));

        node_a.chain_driver.update_consumer(
            &consumer_id,
            &provider_fee,
            node_a.wallets.validator.address.as_str(),
        )?;

        thread::sleep(std::time::Duration::from_secs(3));

        let node_b = bootstrap_consumer_node(
            builder,
            &consumer_id,
            &node_a,
            |config| self.test.get_overrides().modify_node_config(config),
            |genesis| self.test.get_overrides().modify_genesis_file(genesis),
            1,
            &node_a.chain_driver,
            &provider_fee,
        )?;

        let _node_process_a = node_a.process.clone();
        let _node_process_b = node_b.process.clone();

        self.test.run(config, node_a, node_b)?;

        Ok(())
    }
}

impl<Test, Overrides> HasOverrides for RunInterchainSecurityChainTest<'_, Test>
where
    Test: HasOverrides<Overrides = Overrides>,
{
    type Overrides = Overrides;

    fn get_overrides(&self) -> &Self::Overrides {
        self.test.get_overrides()
    }
}