test(e2e): three-nodes and exchange rates tests pass

Author: gakonst

crates/ilp-node/src/node.rs

@@ -249,7 +249,7 @@ impl InterledgerNode {
         //         Err(())
         //     }
         // } else {
-            self.serve_node().await
+        self.serve_node().await
         // }
     }
 
@@ -394,7 +394,7 @@ impl InterledgerNode {
         let incoming_service = Router::new(
             store.clone(),
             // Add tracing to add the outgoing request details to the incoming span
-            outgoing_service.clone() // .wrap(trace_forwarding),
+            outgoing_service.clone(), // .wrap(trace_forwarding),
         );
 
         // Add tracing to track the outgoing request details
@@ -491,10 +491,10 @@ impl InterledgerNode {
                 store.clone(),
             )
             .as_filter())
-            .or(btp_service_as_filter(
-                btp_server_service_clone,
-                store.clone(),
-            ))
+            // .or(btp_service_as_filter(
+            //     btp_server_service_clone,
+            //     store.clone(),
+            // ))
             .recover(default_rejection_handler)
             .with(warp::log("interledger-api"))
             .boxed();
@@ -514,9 +514,9 @@ impl InterledgerNode {
                 exchange_rate_poll_failure_tolerance,
                 store.clone(),
             );
-        // This function does not compile on 1.39 for some reason.
-        // exchange_rate_fetcher
-        //     .spawn_interval(Duration::from_millis(exchange_rate_poll_interval));
+            // This function does not compile on 1.39 for some reason.
+            exchange_rate_fetcher
+                .spawn_interval(Duration::from_millis(exchange_rate_poll_interval));
         } else {
             debug!(target: "interledger-node", "Not using exchange rate provider. Rates must be set via the HTTP API");
         }

crates/ilp-node/tests/redis/exchange_rates.rs

@@ -2,25 +2,20 @@ use crate::redis_helpers::*;
 use crate::test_helpers::*;
 use futures::Future;
 use ilp_node::InterledgerNode;
-use reqwest::r#async::Client;
+use reqwest::Client;
 use secrecy::SecretString;
 use serde_json::{self, json, Value};
 use std::env;
+use std::time::Duration;
 use tokio::runtime::Builder as RuntimeBuilder;
 use tokio_retry::{strategy::FibonacciBackoff, Retry};
 use tracing::error;
 use tracing_subscriber;
 
-#[test]
-fn coincap() {
-    install_tracing_subscriber();
+#[tokio::test]
+async fn coincap() {
     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(None);
 
     let node: InterledgerNode = serde_json::from_value(json!({
@@ -33,56 +28,38 @@ fn coincap() {
         "secret_seed": random_secret(),
         "route_broadcast_interval": 200,
         "exchange_rate": {
-            "poll_interval": 60000,
+            "poll_interval": 100,
             "provider": "coincap",
         },
     }))
     .unwrap();
-    runtime.spawn(node.serve());
+    node.serve().await.unwrap();
 
-    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");
-                }
+    // Wait a few seconds so our node can poll the API
+    tokio::time::delay_for(Duration::from_millis(1000)).await;
 
-                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)
-                }),
-        )
+    let ret = Client::new()
+        .get(&format!("http://localhost:{}/rates", http_port))
+        .send()
+        .await
         .unwrap();
+    let txt = ret.text().await.unwrap();
+    let obj: Value = serde_json::from_str(&txt).unwrap();
+
+    assert_eq!(
+        format!("{}", obj.get("USD").expect("Should have USD rate")).as_str(),
+        "1.0"
+    );
+    assert!(obj.get("EUR").is_some());
+    assert!(obj.get("JPY").is_some());
+    assert!(obj.get("BTC").is_some());
+    assert!(obj.get("ETH").is_some());
+    assert!(obj.get("XRP").is_some());
 }
 
 // TODO can we disable this with conditional compilation?
-#[test]
-fn cryptocompare() {
+#[tokio::test]
+async fn cryptocompare() {
     tracing_subscriber::fmt::try_init().unwrap_or(());
     let context = TestContext::new();
 
@@ -93,11 +70,6 @@ fn cryptocompare() {
     }
     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!({
@@ -118,42 +90,21 @@ fn cryptocompare() {
         },
     }))
     .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");
-                }
+    node.serve().await.unwrap();
 
-                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)
-                }),
-        )
+    let ret = Client::new()
+        .get(&format!("http://localhost:{}/rates", http_port))
+        .send()
+        .await
         .unwrap();
+    let txt = ret.text().await.unwrap();
+    let obj: Value = serde_json::from_str(&txt).unwrap();
+
+    assert_eq!(
+        format!("{}", obj.get("USD").expect("Should have USD rate")).as_str(),
+        "1.0"
+    );
+    assert!(obj.get("BTC").is_some());
+    assert!(obj.get("ETH").is_some());
+    assert!(obj.get("XRP").is_some());
 }

crates/ilp-node/tests/redis/redis_tests.rs

@@ -1,6 +1,6 @@
-#![type_length_limit="3000000"]
+#![type_length_limit = "3000000"]
 // mod btp;
-// mod exchange_rates;
+mod exchange_rates;
 // mod prometheus;
 mod three_nodes;
 

crates/ilp-node/tests/redis/test_helpers.rs

@@ -37,7 +37,7 @@ pub async fn create_account_on_node<T: Serialize>(
     api_port: u16,
     data: T,
     auth: &str,
-) -> Result<String, ()> {
+) -> Result<Account, ()> {
     let client = reqwest::Client::new();
     let res = client
         .post(&format!("http://localhost:{}/accounts", api_port))
@@ -50,9 +50,7 @@ pub async fn create_account_on_node<T: Serialize>(
 
     let res = res.error_for_status().map_err(|_| ())?;
 
-    let data: bytes05::Bytes = res.bytes().map_err(|_| ()).await?;
-
-    Ok(str::from_utf8(&data).unwrap().to_string())
+    Ok(res.json::<Account>().map_err(|_| ()).await.unwrap())
 }
 
 #[allow(unused)]
@@ -101,7 +99,6 @@ pub async fn send_money_to_username<T: Display + Debug>(
         .await?;
 
     let res = res.error_for_status().map_err(|_| ())?;
-    // does this work?
     Ok(res.json::<StreamDelivery>().await.unwrap())
 }
 

crates/ilp-node/tests/redis/three_nodes.rs

@@ -65,7 +65,11 @@ async fn three_nodes() {
         "username": "charlie_on_b",
         "asset_code": "ABC",
         "asset_scale": 6,
-        "ilp_over_btp_incoming_token" : "three",
+        // "ilp_over_btp_incoming_token" : "three",
+        // TODO: remove these and replace with BTP once it's solved
+        "ilp_over_http_outgoing_token": "two",
+        "ilp_over_http_incoming_token": "three",
+        "ilp_over_http_url": format!("http://localhost:{}/accounts/{}/ilp", node3_http, "bob_on_c"),
         "min_balance": -1_000_000_000,
         "routing_relation": "Child",
     });
@@ -81,13 +85,15 @@ async fn three_nodes() {
         "username": "bob_on_c",
         "asset_code": "ABC",
         "asset_scale": 6,
-        "ilp_over_http_incoming_token" : "two",
         "ilp_over_http_outgoing_token": "three",
-        "ilp_over_btp_url": format!("btp+ws://localhost:{}/accounts/{}/ilp/btp", node2_http, "charlie_on_b"),
-        "ilp_over_btp_outgoing_token": "three",
+        "ilp_over_http_incoming_token" : "two",
+        "ilp_over_http_url": format!("http://localhost:{}/accounts/{}/ilp", node2_http, "charlie_on_b"),
         "min_balance": -1_000_000_000,
         "routing_relation": "Parent",
     });
+    // json! does not take comments into account!
+    // "ilp_over_btp_url": format!("btp+ws://localhost:{}/accounts/{}/ilp/btp", node2_http, "charlie_on_b"),
+    // "ilp_over_btp_outgoing_token": "three",
 
     let node1: InterledgerNode = serde_json::from_value(json!({
         "ilp_address": "example.alice",
@@ -133,24 +139,37 @@ async fn three_nodes() {
     .expect("Error creating node3.");
 
     node1.serve().await.unwrap(); // .instrument(error_span!(target: "interledger", "node1")).await.unwrap();
-    create_account_on_node(node1_http, alice_on_alice, "admin").await.unwrap();
-    create_account_on_node(node1_http, bob_on_alice, "admin").await.unwrap();
+    create_account_on_node(node1_http, alice_on_alice, "admin")
+        .await
+        .unwrap();
+    create_account_on_node(node1_http, bob_on_alice, "admin")
+        .await
+        .unwrap();
 
     node2.serve().await.unwrap(); // .instrument(error_span!(target: "interledger", "node2")).await.unwrap();
-    create_account_on_node(node2_http, alice_on_bob, "admin").await.unwrap();
-    create_account_on_node(node2_http, charlie_on_bob, "admin").await.unwrap();
+    create_account_on_node(node2_http, alice_on_bob, "admin")
+        .await
+        .unwrap();
+    create_account_on_node(node2_http, charlie_on_bob, "admin")
+        .await
+        .unwrap();
     // Also set exchange rates
     let client = reqwest::Client::new();
     client
         .put(&format!("http://localhost:{}/rates", node2_http))
         .header("Authorization", "Bearer admin")
         .json(&json!({"ABC": 1, "XYZ": 2}))
         .send()
-        .await.unwrap();
+        .await
+        .unwrap();
 
     node3.serve().await.unwrap(); // .instrument(error_span!(target: "interledger", "node3")).await.unwrap();
-    create_account_on_node(node3_http, charlie_on_charlie, "admin").await.unwrap();
-    create_account_on_node(node3_http, bob_on_charlie, "admin").await.unwrap();
+    let acc = create_account_on_node(node3_http, charlie_on_charlie, "admin")
+        .await
+        .unwrap();
+    create_account_on_node(node3_http, bob_on_charlie, "admin")
+        .await
+        .unwrap();
 
     delay(1000).await;
 
@@ -173,7 +192,9 @@ async fn three_nodes() {
         "charlie_on_c",
         "alice_on_a",
         "default account holder",
-    ).await.unwrap();
+    )
+    .await
+    .unwrap();
 
     assert_eq!(
         receipt.from,
@@ -225,7 +246,9 @@ async fn three_nodes() {
         "alice_on_a",
         "charlie_on_c",
         "default account holder",
-    ).await.unwrap();
+    )
+    .await
+    .unwrap();
 
     assert_eq!(
         receipt.from,

crates/interledger-api/src/routes/accounts.rs

@@ -73,10 +73,8 @@ where
             let admin_auth_header = admin_auth_header_clone.clone();
             async move {
                 if authorization.expose_secret() == &admin_auth_header {
-                    println!("autorized!");
                     Ok::<(), Rejection>(())
                 } else {
-                    println!("unautorized!");
                     Err(Rejection::from(ApiError::unauthorized()))
                 }
             }
@@ -398,6 +396,7 @@ where
     // GET /accounts/:username/spsp
     let server_secret_clone = server_secret.clone();
     let get_spsp = warp::get()
+        .and(warp::path("accounts"))
         .and(account_username_to_id)
         .and(warp::path("spsp"))
         .and(warp::path::end())
@@ -676,6 +675,7 @@ pub fn deserialize_json<T: DeserializeOwned + Send>(
 #[cfg(test)]
 mod tests {
     use crate::routes::test_helpers::*;
+    // TODO: Add test for GET /accounts/:username/spsp and /.well_known
 
     #[tokio::test]
     async fn only_admin_can_create_account() {

crates/interledger-api/src/routes/node_settings.rs

@@ -197,7 +197,6 @@ where
         .and(with_store.clone())
         .and_then(|prefix: String, body: bytes05::Bytes, store: S| {
             async move {
-                println!("TRYING TO PARSE USERNAEME");
                 let username_str =
                     str::from_utf8(&body).map_err(|_| Rejection::from(ApiError::bad_request()))?;
                 let username = Username::from_str(username_str)