test: add seed node to net/test.rs

src/net/tests.rs

@@ -31,16 +31,16 @@ use crate::{
 };
 
 // Number of nodes to spawn and number of peers each node connects to
-const N_NODES: usize = 3;
-const N_CONNS: usize = 2;
+const N_NODES: usize = 6;
+const N_CONNS: usize = 1;
 
 #[test]
 fn p2p_test() {
     let mut cfg = simplelog::ConfigBuilder::new();
 
     simplelog::TermLogger::init(
-        //simplelog::LevelFilter::Info,
-        simplelog::LevelFilter::Debug,
+        simplelog::LevelFilter::Info,
+        //simplelog::LevelFilter::Debug,
         //simplelog::LevelFilter::Trace,
         cfg.build(),
         simplelog::TerminalMode::Mixed,
@@ -69,30 +69,47 @@ async fn hostlist_propagation(ex: Arc<Executor<'static>>) {
     let mut p2p_instances = vec![];
     let mut rng = rand::thread_rng();
 
+    let settings = Settings {
+        localnet: true,
+        inbound_addrs: vec![seed_addr.clone()],
+        external_addrs: vec![seed_addr.clone()],
+        outbound_connections: 2,
+        //outbound_connect_timeout: 10,
+        inbound_connections: usize::MAX,
+        seeds: vec![],
+        hostlist: String::from("~/.config/darkfi/seed.tsv"),
+        peers: vec![],
+        allowed_transports: vec!["tcp".to_string()],
+        node_id: "seed".to_string(),
+        ..Default::default()
+    };
+
+    let p2p = P2p::new(settings, ex.clone()).await;
+    p2p_instances.push(p2p);
+
     info!("Initializing outbound nodes");
     for i in 0..N_NODES {
         // Everyone will connect to N_CONNS random peers.
         let mut peers = vec![];
-        for _ in 0..N_CONNS {
-            let mut port = 13200 + i;
-            while port == 13200 + i {
-                port = 13200 + rng.gen_range(0..N_NODES);
-            }
-            peers.push(Url::parse(&format!("tcp://127.0.0.1:{}", port)).unwrap());
-        }
+        //for _ in 0..N_CONNS {
+        //    let mut port = 13200 + i;
+        //    while port == 13200 + i {
+        //        port = 13200 + rng.gen_range(0..N_NODES);
+        //    }
+        //    peers.push(Url::parse(&format!("tcp://127.0.0.1:{}", port)).unwrap());
+        //}
         let settings = Settings {
             localnet: true,
             inbound_addrs: vec![Url::parse(&format!("tcp://127.0.0.1:{}", 13200 + i)).unwrap()],
             external_addrs: vec![Url::parse(&format!("tcp://127.0.0.1:{}", 13200 + i)).unwrap()],
             outbound_connections: 2,
-            outbound_connect_timeout: 10,
+            //outbound_connect_timeout: 10,
             inbound_connections: usize::MAX,
             seeds: vec![seed_addr.clone()],
             hostlist: String::from(format!("~/.config/darkfi/hosts{}.tsv", i)),
             peers,
             allowed_transports: vec!["tcp".to_string()],
             node_id: i.to_string(),
-            //advertise: true,
             ..Default::default()
         };
 
@@ -101,40 +118,41 @@ async fn hostlist_propagation(ex: Arc<Executor<'static>>) {
     }
     // Start the P2P network
     for p2p in p2p_instances.iter() {
-        assert!(p2p.settings().advertise == true);
+        //assert!(p2p.settings().advertise == true);
         p2p.clone().start().await.unwrap();
     }
 
     info!("Waiting until all peers connect");
-    sleep(60).await;
+    sleep(15).await;
 
-    info!("Inspecting hostlists...");
-    for p2p in p2p_instances.iter() {
-        let hosts = p2p.hosts();
-        //assert!(!hosts.is_empty_greylist().await);
-        //assert!(!hosts.is_empty_whitelist().await);
-        //assert!(!hosts.is_empty_anchorlist().await);
-
-        let greylist = hosts.greylist.read().await;
-        let whitelist = hosts.whitelist.read().await;
-        let anchorlist = hosts.anchorlist.read().await;
-
-        info!("Node {}", p2p.settings().node_id);
-        for (i, (url, last_seen)) in greylist.iter().enumerate() {
-            info!("Greylist entry {}: {}, {}", i, url, last_seen);
-        }
-
-        for (i, (url, last_seen)) in whitelist.iter().enumerate() {
-            info!("Whitelist entry {}: {}, {}", i, url, last_seen);
-        }
-
-        for (i, (url, last_seen)) in anchorlist.iter().enumerate() {
-            info!("Anchorlist entry {}: {}, {}", i, url, last_seen);
-        }
-    }
+    //info!("Inspecting hostlists...");
+    //for p2p in p2p_instances.iter() {
+    //    let hosts = p2p.hosts();
+    //    //assert!(!hosts.is_empty_greylist().await);
+    //    //assert!(!hosts.is_empty_whitelist().await);
+    //    //assert!(!hosts.is_empty_anchorlist().await);
+
+    //    let greylist = hosts.greylist.read().await;
+    //    let whitelist = hosts.whitelist.read().await;
+    //    let anchorlist = hosts.anchorlist.read().await;
+
+    //    info!("Node {}", p2p.settings().node_id);
+    //    for (i, (url, last_seen)) in greylist.iter().enumerate() {
+    //        info!("Greylist entry {}: {}, {}", i, url, last_seen);
+    //    }
+
+    //    for (i, (url, last_seen)) in whitelist.iter().enumerate() {
+    //        info!("Whitelist entry {}: {}, {}", i, url, last_seen);
+    //    }
+
+    //    for (i, (url, last_seen)) in anchorlist.iter().enumerate() {
+    //        info!("Anchorlist entry {}: {}, {}", i, url, last_seen);
+    //    }
+    //}
 
     // Stop the P2P network
     for p2p in p2p_instances.iter() {
+        info!("Stopping P2P instances...");
         p2p.clone().stop().await;
     }
 }