add daemon mining test from kaspanet#249

kaspad/src/args.rs

@@ -21,7 +21,7 @@ use kaspa_core::kaspad_env::version;
 use kaspa_utils::networking::{ContextualNetAddress, IpAddress};
 use kaspa_wrpc_server::address::WrpcNetAddress;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Args {
     // NOTE: it is best if property names match config file fields
     pub appdir: Option<String>,

testing/integration/Cargo.toml

@@ -59,7 +59,6 @@ criterion.workspace = true
 rand = { workspace = true, features = ["small_rng"] }
 tokio = { workspace = true, features = ["rt", "macros"] }
 kaspa-txscript-errors.workspace = true
-port-selector = "0.1.6"
 
 [features]
 html_reports = []

testing/integration/src/common/daemon.rs

@@ -1,4 +1,5 @@
-use kaspa_core::core::Core;
+use kaspa_consensus_core::network::NetworkId;
+use kaspa_core::{core::Core, signals::Shutdown};
 use kaspa_database::utils::get_kaspa_tempdir;
 use kaspa_grpc_client::GrpcClient;
 use kaspa_rpc_core::notify::mode::NotificationMode;
@@ -7,8 +8,16 @@ use std::{sync::Arc, time::Duration};
 use tempfile::TempDir;
 
 pub struct Daemon {
-    pub core: Arc<Core>,
+    // Type and suffix of the daemon network
+    pub network: NetworkId,
+
+    // Daemon ports
     pub rpc_port: u16,
+    pub p2p_port: u16,
+
+    core: Arc<Core>,
+    workers: Option<Vec<std::thread::JoinHandle<()>>>,
+
     _appdir_tempdir: TempDir,
 }
 
@@ -44,24 +53,23 @@ impl Daemon {
         let appdir_tempdir = get_kaspa_tempdir();
         args.appdir = Some(appdir_tempdir.path().to_str().unwrap().to_owned());
 
+        let network = args.network();
         let core = create_core_with_runtime(&Default::default(), &args);
-        Daemon { core, rpc_port, _appdir_tempdir: appdir_tempdir }
+        Daemon { network, rpc_port, p2p_port, core, workers: None, _appdir_tempdir: appdir_tempdir }
     }
 
-    pub async fn start(&self) -> (Vec<std::thread::JoinHandle<()>>, GrpcClient) {
-        let workers = self.core.start();
+    pub async fn start(&mut self) -> GrpcClient {
+        self.workers = Some(self.core.start());
+        // Wait for the node to initialize before connecting to RPC
         tokio::time::sleep(Duration::from_secs(1)).await;
-        let rpc_client = GrpcClient::connect(
-            NotificationMode::Direct,
-            format!("grpc://localhost:{}", self.rpc_port),
-            true,
-            None,
-            false,
-            Some(500_000),
-        )
-        .await
-        .unwrap();
-        (workers, rpc_client)
+        self.new_client().await
+    }
+
+    pub fn shutdown(&mut self) {
+        if let Some(workers) = self.workers.take() {
+            self.core.shutdown();
+            self.core.join(workers);
+        }
     }
 
     pub async fn new_client(&self) -> GrpcClient {
@@ -70,3 +78,9 @@ impl Daemon {
             .unwrap()
     }
 }
+
+impl Drop for Daemon {
+    fn drop(&mut self) {
+        self.shutdown()
+    }
+}

testing/integration/src/daemon_integration_tests.rs

@@ -1,23 +1,52 @@
+use kaspa_addresses::Address;
+use kaspa_rpc_core::api::rpc::RpcApi;
+use kaspad::args::Args;
+
 use crate::common::daemon::Daemon;
-use kaspa_core::signals::Shutdown;
 use std::time::Duration;
 
 #[tokio::test]
 async fn daemon_sanity_test() {
-    let core1 = Daemon::new_random();
-    let (workers1, rpc_client1) = core1.start().await;
+    let mut kaspad1 = Daemon::new_random();
+    let rpc_client1 = kaspad1.start().await;
 
-    let core2 = Daemon::new_random();
-    let (workers2, rpc_client2) = core2.start().await;
+    let mut kaspad2 = Daemon::new_random();
+    let rpc_client2 = kaspad2.start().await;
 
     tokio::time::sleep(Duration::from_secs(1)).await;
     rpc_client1.disconnect().await.unwrap();
     drop(rpc_client1);
-    core1.core.shutdown();
-    core1.core.join(workers1);
+    kaspad1.shutdown();
 
     rpc_client2.disconnect().await.unwrap();
     drop(rpc_client2);
-    core2.core.shutdown();
-    core2.core.join(workers2);
+    kaspad2.shutdown();
+}
+
+#[tokio::test]
+async fn daemon_mining_test() {
+    kaspa_core::log::try_init_logger("INFO");
+
+    let args = Args { simnet: true, unsafe_rpc: true, enable_unsynced_mining: true, ..Default::default() };
+    let mut kaspad1 = Daemon::new_random_with_args(args.clone());
+    let mut kaspad2 = Daemon::new_random_with_args(args);
+    let rpc_client1 = kaspad1.start().await;
+    let rpc_client2 = kaspad2.start().await;
+
+    rpc_client2.add_peer(format!("127.0.0.1:{}", kaspad1.p2p_port).try_into().unwrap(), true).await.unwrap();
+    tokio::time::sleep(Duration::from_secs(1)).await; // Let it connect
+    assert_eq!(rpc_client2.get_connected_peer_info().await.unwrap().peer_info.len(), 1);
+
+    // Mine 10 blocks to daemon #1
+    for _ in 0..10 {
+        let template = rpc_client1
+            .get_block_template(Address::new(kaspad1.network.into(), kaspa_addresses::Version::PubKey, &[0; 32]), vec![])
+            .await
+            .unwrap();
+        rpc_client1.submit_block(template.block, false).await.unwrap();
+    }
+
+    tokio::time::sleep(Duration::from_secs(1)).await;
+    // Expect the blocks to be relayed to daemon #2
+    assert_eq!(rpc_client2.get_block_dag_info().await.unwrap().block_count, 10);
 }

testing/integration/src/mempool_benchmarks.rs

@@ -14,7 +14,7 @@ use kaspa_consensus_core::{
         utxo_diff::UtxoDiff,
     },
 };
-use kaspa_core::{debug, info, signals::Shutdown, time::Stopwatch};
+use kaspa_core::{debug, info, time::Stopwatch};
 use kaspa_notify::{
     listener::ListenerId,
     notifier::Notify,
@@ -179,8 +179,8 @@ async fn bench_bbt_latency() {
     verify_tx_dag(&utxoset, &txs);
     info!("Generated overall {} txs", txs.len());
 
-    let daemon = Daemon::new_random_with_args(args);
-    let (workers, client) = daemon.start().await;
+    let mut daemon = Daemon::new_random_with_args(args);
+    let client = daemon.start().await;
     // TODO: use only a single client once grpc server-side supports concurrent requests
     let block_template_client = daemon.new_client().await;
     let submit_block_client = daemon.new_client().await;
@@ -269,6 +269,5 @@ async fn bench_bbt_latency() {
     // tokio::time::sleep(std::time::Duration::from_secs(5)).await;
     client.disconnect().await.unwrap();
     drop(client);
-    daemon.core.shutdown();
-    daemon.core.join(workers);
+    daemon.shutdown();
 }