Merge pull request #232 from p2pderivatives/fix/add-missing-sample-test

Fix/add missing sample test

sample/examples/configurations/alice.yml

@@ -7,6 +7,5 @@ bitcoinInfo:
 storageDirPath: './dlc_sample_alice'
 networkConfiguration:
   peerListeningPort: 9000
-network: regtest
 oracleConfig:
   host: 'http://localhost:8080/'

sample/examples/configurations/bob.yml

@@ -7,6 +7,5 @@ bitcoinInfo:
 storageDirPath: './dlc_sample_bob'
 networkConfiguration:
   peerListeningPort: 9001
-network: regtest
 oracleConfig:
   host: 'http://localhost:8080/'

sample/src/cli.rs

@@ -3,7 +3,6 @@ use crate::hex_utils;
 use crate::DlcManager;
 use crate::DlcMessageHandler;
 use crate::PeerManager;
-use bitcoin::network::constants::Network;
 use bitcoin::secp256k1::PublicKey;
 use dlc_manager::channel::signed_channel::SignedChannelState;
 use dlc_manager::channel::signed_channel::SignedChannelStateType;
@@ -12,15 +11,13 @@ use dlc_manager::contract::Contract;
 use dlc_manager::Storage;
 use dlc_messages::Message as DlcMessage;
 use hex_utils::{hex_str, to_slice};
-use lightning::ln::msgs::SocketAddress;
 use serde::Deserialize;
 use serde_json::Value;
 use std::convert::TryInto;
 use std::fs;
 use std::io;
 use std::io::{BufRead, Write};
-use std::net::{IpAddr, SocketAddr, ToSocketAddrs};
-use std::str::FromStr;
+use std::net::{SocketAddr, ToSocketAddrs};
 use std::str::SplitWhitespace;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
@@ -44,7 +41,6 @@ pub struct OracleConfig {
 #[derive(Debug)]
 pub struct NetworkConfig {
     pub peer_listening_port: u16,
-    pub announced_listen_addr: Option<SocketAddress>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -54,9 +50,6 @@ pub struct Configuration {
     pub storage_dir_path: String,
     #[serde(deserialize_with = "deserialize_network_configuration")]
     pub network_configuration: NetworkConfig,
-    #[serde(default)]
-    pub announced_node_name: [u8; 32],
-    pub network: Network,
     pub oracle_config: OracleConfig,
 }
 
@@ -72,29 +65,8 @@ where
         .try_into()
         .expect("Could not fit port in u16");
 
-    let announced_listen_addr = if let Some(announced_listen_addr) = val.get("announcedListenAddr")
-    {
-        let buf = announced_listen_addr
-            .as_str()
-            .expect("Error parsing announcedListenAddr");
-        match IpAddr::from_str(buf) {
-            Ok(IpAddr::V4(a)) => Some(SocketAddress::TcpIpV4 {
-                addr: a.octets(),
-                port: peer_listening_port,
-            }),
-            Ok(IpAddr::V6(a)) => Some(SocketAddress::TcpIpV6 {
-                addr: a.octets(),
-                port: peer_listening_port,
-            }),
-            Err(_) => panic!("Failed to parse announced-listen-addr into an IP address"),
-        }
-    } else {
-        None
-    };
-
     Ok(NetworkConfig {
         peer_listening_port,
-        announced_listen_addr,
     })
 }
 

sample/tests/cli_tests.rs

@@ -0,0 +1,84 @@
+use std::{process::Command, thread::sleep, time::Duration};
+
+use assert_cmd::cargo::cargo_bin;
+use dlc_manager::contract::contract_input::ContractInput;
+use rexpect::session::{spawn_command, PtySession};
+
+#[test]
+#[ignore]
+fn sample_cli_test() {
+    let contract_str = include_str!("../examples/contracts/numerical_contract_input.json");
+    let mut contract: ContractInput = serde_json::from_str(&contract_str).unwrap();
+    let time_now = std::time::SystemTime::now();
+    let unix_time = (time_now
+        .duration_since(std::time::SystemTime::UNIX_EPOCH)
+        .unwrap()
+        + Duration::new(300, 0))
+    .as_secs();
+    contract.contract_infos[0].oracles.event_id = format!("btcusd{}", unix_time);
+
+    let alice_config_str = include_str!("../examples/configurations/alice.yml");
+    let bob_config_str = include_str!("../examples/configurations/bob.yml");
+    std::fs::write(
+        "./numerical_contract_input.json",
+        serde_json::to_string(&contract).unwrap(),
+    )
+    .unwrap();
+    std::fs::write("./alice.yml", alice_config_str).unwrap();
+    std::fs::write("./bob.yml", bob_config_str).unwrap();
+
+    let bin_path = cargo_bin("sample");
+    let mut command = Command::new(bin_path.to_str().unwrap());
+    command.arg("./alice.yml");
+    let mut alice_cli = spawn_command(command, Some(5000)).unwrap();
+
+    alice_cli.exp_regex("[a-f0-9]{66}").unwrap();
+    alice_cli.exp_regex("> $").unwrap();
+
+    let mut command = Command::new(bin_path.to_str().unwrap());
+    command.arg("./bob.yml");
+    let mut bob_cli = spawn_command(command, Some(5000)).unwrap();
+
+    let (_, bob_ip) = bob_cli.exp_regex("[a-f0-9]{66}").unwrap();
+    bob_cli.exp_regex("> $").unwrap();
+
+    alice_cli
+        .send_line(&format!(
+            "offercontract {}@127.0.0.1:9001 ./numerical_contract_input.json",
+            bob_ip
+        ))
+        .unwrap();
+
+    alice_cli.exp_char('>').unwrap();
+
+    std::thread::sleep(std::time::Duration::from_secs(5));
+
+    try_send_until(&mut bob_cli, "listoffers", "Offer");
+
+    let (_, offer_id) = bob_cli.exp_regex("[a-f0-9]{64}").unwrap();
+
+    bob_cli
+        .send_line(&format!("acceptoffer {}", offer_id))
+        .unwrap();
+    bob_cli.exp_char('>').unwrap();
+
+    try_send_until(&mut alice_cli, "listcontracts", "Signed contract");
+    alice_cli.exp_char('>').unwrap();
+
+    try_send_until(&mut bob_cli, "listcontracts", "Signed contract");
+    bob_cli.exp_char('>').unwrap();
+}
+
+fn try_send_until(session: &mut PtySession, to_send: &str, expected: &str) {
+    const RETRY: u8 = 5;
+
+    for _ in 0..RETRY {
+        session.send_line(to_send).unwrap();
+        if let Ok(_) = session.exp_string(expected) {
+            return;
+        }
+        sleep(Duration::from_secs(1));
+    }
+
+    panic!("Did not receive expected output after {} tries", RETRY);
+}