ilp-node 0.6.0

Interledger node (sender, connector, receiver bundle)
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use futures::Future;
use ilp_node::InterledgerNode;
use reqwest::r#async::Client;
use secrecy::SecretString;
use serde_json::{self, json, Value};
use std::env;
use tokio::runtime::Builder as RuntimeBuilder;
use tokio_retry::{strategy::FibonacciBackoff, Retry};
use tracing::error;
use tracing_subscriber;

mod redis_helpers;
use redis_helpers::*;
mod test_helpers;
use test_helpers::*;

#[test]
fn coincap() {
    install_tracing_subscriber();
    let context = TestContext::new();

    let mut runtime = RuntimeBuilder::new()
        .panic_handler(|err| std::panic::resume_unwind(err))
        .build()
        .unwrap();

    let http_port = get_open_port(Some(3010));

    let node: InterledgerNode = serde_json::from_value(json!({
        "ilp_address": "example.one",
        "default_spsp_account": "one",
        "admin_auth_token": "admin",
        "redis_connection": connection_info_to_string(context.get_client_connection_info()),
        "http_bind_address": format!("127.0.0.1:{}", http_port),
        "settlement_api_bind_address": format!("127.0.0.1:{}", get_open_port(None)),
        "secret_seed": random_secret(),
        "route_broadcast_interval": 200,
        "exchange_rate_poll_interval": 60000,
        "exchange_rate_provider": "CoinCap",
    }))
    .unwrap();
    runtime.spawn(node.serve());

    let get_rates = move || {
        Client::new()
            .get(&format!("http://localhost:{}/rates", http_port))
            .send()
            .map_err(|_| panic!("Error getting rates"))
            .and_then(|mut res| res.json().map_err(|_| panic!("Error getting body")))
            .and_then(|body: Value| {
                if let Value::Object(obj) = body {
                    if obj.is_empty() {
                        error!("Rates are empty");
                        return Err(());
                    }
                    assert_eq!(
                        format!("{}", obj.get("USD").expect("Should have USD rate")).as_str(),
                        "1.0"
                    );
                    assert!(obj.contains_key("EUR"));
                    assert!(obj.contains_key("JPY"));
                    assert!(obj.contains_key("BTC"));
                    assert!(obj.contains_key("ETH"));
                    assert!(obj.contains_key("XRP"));
                } else {
                    panic!("Not an object");
                }

                Ok(())
            })
    };

    runtime
        .block_on(
            delay(1000)
                .map_err(|_| panic!("Something strange happened"))
                .and_then(move |_| {
                    Retry::spawn(FibonacciBackoff::from_millis(1000).take(5), get_rates)
                }),
        )
        .unwrap();
}

// TODO can we disable this with conditional compilation?
#[test]
fn cryptocompare() {
    tracing_subscriber::fmt::try_init().unwrap_or(());
    let context = TestContext::new();

    let api_key = env::var("ILP_TEST_CRYPTOCOMPARE_API_KEY");
    if api_key.is_err() {
        error!("Skipping cryptocompare test. Must configure an API key by setting ILP_TEST_CRYPTOCOMPARE_API_KEY to run this test");
        return;
    }
    let api_key = SecretString::new(api_key.unwrap());

    let mut runtime = RuntimeBuilder::new()
        .panic_handler(|err| std::panic::resume_unwind(err))
        .build()
        .unwrap();

    let http_port = get_open_port(Some(3011));

    let node: InterledgerNode = serde_json::from_value(json!({
        "ilp_address": "example.one",
        "default_spsp_account": "one",
        "admin_auth_token": "admin",
        "redis_connection": connection_info_to_string(context.get_client_connection_info()),
        "http_bind_address": format!("127.0.0.1:{}", http_port),
        "settlement_api_bind_address": format!("127.0.0.1:{}", get_open_port(None)),
        "secret_seed": random_secret(),
        "route_broadcast_interval": 200,
        "exchange_rate_poll_interval": 60000,
        "exchange_rate_provider": {
            "crypto_compare": api_key
        },
        "exchange_rate_spread": 0.0,
    }))
    .unwrap();
    runtime.spawn(node.serve());

    let get_rates = move || {
        Client::new()
            .get(&format!("http://localhost:{}/rates", http_port))
            .send()
            .map_err(|_| panic!("Error getting rates"))
            .and_then(|mut res| res.json().map_err(|_| panic!("Error getting body")))
            .and_then(|body: Value| {
                if let Value::Object(obj) = body {
                    if obj.is_empty() {
                        error!("Rates are empty");
                        return Err(());
                    }
                    assert_eq!(
                        format!("{}", obj.get("USD").expect("Should have USD rate")).as_str(),
                        "1.0"
                    );
                    assert!(obj.contains_key("BTC"));
                    assert!(obj.contains_key("ETH"));
                    assert!(obj.contains_key("XRP"));
                } else {
                    panic!("Not an object");
                }

                Ok(())
            })
    };

    runtime
        .block_on(
            delay(1000)
                .map_err(|_| panic!("Something strange happened"))
                .and_then(move |_| {
                    Retry::spawn(FibonacciBackoff::from_millis(1000).take(5), get_rates)
                }),
        )
        .unwrap();
}