Merge pull request #236 from jirigrill/unit-tests-validate_activity-validate_node_network

simln-lib/test: unit tests for validate_activity and validate_node_network

Author: carlaKC

Cargo.lock

@@ -30,10 +30,10 @@ hex = "0.4.3"
 csv = "1.2.2"
 serde_millis = "0.1.1"
 rand_distr = "0.4.3"
-mockall = "0.12.1"
 rand_chacha = "0.3.1"
 reqwest = { version = "0.12", features = ["json", "multipart"] }
 tokio-util = { version = "0.7.13", features = ["rt"] }
 
 [dev-dependencies]
 ntest = "0.9.0"
+mockall = "0.13.1"

simln-lib/Cargo.toml

@@ -33,7 +33,6 @@ pub mod lnd;
 mod random_activity;
 pub mod serializers;
 pub mod sim_node;
-#[cfg(test)]
 mod test_utils;
 
 #[derive(Serialize, Debug, Clone)]
@@ -1418,18 +1417,17 @@ async fn track_payment_result(
 #[cfg(test)]
 mod tests {
     use crate::{
-        get_payment_delay, test_utils, LightningError, LightningNode, MutRng, NodeInfo,
-        PaymentGenerationError, PaymentGenerator, Simulation,
+        get_payment_delay, test_utils, test_utils::LightningTestNodeBuilder, LightningError,
+        LightningNode, MutRng, PaymentGenerationError, PaymentGenerator,
     };
-    use async_trait::async_trait;
     use bitcoin::secp256k1::PublicKey;
+    use bitcoin::Network;
     use mockall::mock;
     use std::collections::HashMap;
     use std::fmt;
     use std::sync::Arc;
     use std::time::Duration;
     use tokio::sync::Mutex;
-    use tokio_util::task::TaskTracker;
 
     #[test]
     fn create_seeded_mut_rng() {
@@ -1472,27 +1470,6 @@ mod tests {
         }
     }
 
-    mock! {
-        pub LightningNode {}
-        #[async_trait]
-        impl crate::LightningNode for LightningNode {
-            fn get_info(&self) -> &NodeInfo;
-            async fn get_network(&mut self) -> Result<bitcoin::Network, LightningError>;
-            async fn send_payment(
-                    &mut self,
-                    dest: bitcoin::secp256k1::PublicKey,
-                    amount_msat: u64,
-                ) -> Result<lightning::ln::PaymentHash, LightningError>;
-            async fn track_payment(
-                    &mut self,
-                    hash: &lightning::ln::PaymentHash,
-                    shutdown: triggered::Listener,
-                ) -> Result<crate::PaymentResult, LightningError>;
-            async fn get_node_info(&mut self, node_id: &PublicKey) -> Result<NodeInfo, LightningError>;
-            async fn list_channels(&mut self) -> Result<Vec<u64>, LightningError>;
-        }
-    }
-
     #[test]
     fn test_no_payment_delay() {
         let node = test_utils::create_nodes(1, 100_000)
@@ -1548,33 +1525,178 @@ mod tests {
         );
     }
 
+    /// Verifies that an empty activity (for random generation) is valid when two nodes with keysend
+    /// support are present, expecting an `Ok` result.
+    #[tokio::test]
+    async fn test_validate_activity_empty_with_sufficient_nodes() {
+        let (_, clients) = LightningTestNodeBuilder::new(3).build_full();
+        let simulation = test_utils::create_simulation(clients, vec![]);
+        let result = simulation.validate_activity().await;
+        assert!(result.is_ok());
+    }
+
+    /// Verifies that an empty activity fails validation with only one keysend-enabled node,
+    /// expecting a `ValidationError` with "At least two nodes required".
+    #[tokio::test]
+    async fn test_validate_activity_empty_with_insufficient_nodes() {
+        let (_, clients) = LightningTestNodeBuilder::new(1).build_full();
+        let simulation = test_utils::create_simulation(clients, vec![]);
+        let result = simulation.validate_activity().await;
+
+        assert!(result.is_err());
+        assert!(matches!(result, 
+            Err(LightningError::ValidationError(msg)) if msg.contains("At least two nodes required")));
+    }
+
+    /// Verifies that an empty activity fails when one of two nodes doesn’t support keysend,
+    /// expecting a `ValidationError` with "must support keysend".
+    #[tokio::test]
+    async fn test_validate_activity_empty_with_non_keysend_node() {
+        let (_, clients) = LightningTestNodeBuilder::new(2)
+            .with_keysend_nodes(vec![0])
+            .build_full();
+        let simulation = test_utils::create_simulation(clients, vec![]);
+        let result = simulation.validate_activity().await;
+
+        assert!(result.is_err());
+        assert!(matches!(result, 
+            Err(LightningError::ValidationError(msg)) if msg.contains("must support keysend")));
+    }
+
+    /// Verifies that an activity fails when the source node isn’t in the clients map,
+    /// expecting a `ValidationError` with "Source node not found".
+    #[tokio::test]
+    async fn test_validate_activity_with_missing_source_node() {
+        let (nodes, clients) = LightningTestNodeBuilder::new(1).build_full();
+        let missing_nodes = test_utils::create_nodes(1, 100_000);
+        let missing_node = missing_nodes.first().unwrap().0.clone();
+        let dest_node = nodes[0].clone();
+
+        let activity = test_utils::create_activity(missing_node, dest_node, 1000);
+        let simulation = test_utils::create_simulation(clients, vec![activity]);
+        let result = simulation.validate_activity().await;
+
+        assert!(result.is_err());
+        assert!(matches!(result, 
+            Err(LightningError::ValidationError(msg)) if msg.contains("Source node not found")));
+    }
+
+    /// Verifies that an activity fails when the destination lacks keysend support,
+    /// expecting a `ValidationError` with "does not support keysend".
+    #[tokio::test]
+    async fn test_validate_activity_with_non_keysend_destination() {
+        let (nodes, clients) = LightningTestNodeBuilder::new(1).build_full();
+        let dest_nodes = test_utils::create_nodes(1, 100_000);
+        let dest_node = dest_nodes.first().unwrap().0.clone();
+
+        let activity = test_utils::create_activity(nodes[0].clone(), dest_node, 1000);
+        let simulation = test_utils::create_simulation(clients, vec![activity]);
+        let result = simulation.validate_activity().await;
+
+        assert!(result.is_err());
+        assert!(matches!(result, 
+            Err(LightningError::ValidationError(msg)) if msg.contains("does not support keysend")));
+    }
+
+    /// Verifies that an activity with a non-zero amount between two keysend-enabled nodes
+    /// passes validation, expecting an `Ok` result.
+    #[tokio::test]
+    async fn test_validate_activity_valid_payment_flow() {
+        let (nodes, clients) = LightningTestNodeBuilder::new(1).build_full();
+        let dest_nodes = test_utils::create_nodes(1, 100_000);
+        let mut dest_node = dest_nodes.first().unwrap().0.clone();
+        dest_node.features.set_keysend_optional();
+
+        let activity = test_utils::create_activity(nodes[0].clone(), dest_node, 1000);
+        let simulation = test_utils::create_simulation(clients, vec![activity]);
+        let result = simulation.validate_activity().await;
+
+        assert!(result.is_ok());
+    }
+
+    /// Verifies that an activity with a zero amount between two keysend-enabled nodes fails,
+    /// expecting a `ValidationError` with "zero values".
     #[tokio::test]
     async fn test_validate_zero_amount_no_valid() {
-        let nodes = test_utils::create_nodes(2, 100_000);
-        let mut node_1 = nodes.first().unwrap().0.clone();
-        let mut node_2 = nodes.get(1).unwrap().0.clone();
-        node_1.features.set_keysend_optional();
-        node_2.features.set_keysend_optional();
-
-        let mock_node_1 = MockLightningNode::new();
-        let mock_node_2 = MockLightningNode::new();
-        let mut clients: HashMap<PublicKey, Arc<Mutex<dyn LightningNode>>> = HashMap::new();
-        clients.insert(node_1.pubkey, Arc::new(Mutex::new(mock_node_1)));
-        clients.insert(node_2.pubkey, Arc::new(Mutex::new(mock_node_2)));
-        let activity_definition = crate::ActivityDefinition {
-            source: node_1,
-            destination: node_2,
-            start_secs: None,
-            count: None,
-            interval_secs: crate::ValueOrRange::Value(0),
-            amount_msat: crate::ValueOrRange::Value(0),
-        };
-        let simulation = Simulation::new(
-            crate::SimulationCfg::new(Some(0), 0, 0.0, None, None),
-            clients,
-            vec![activity_definition],
-            TaskTracker::new(),
-        );
-        assert!(simulation.validate_activity().await.is_err());
+        let (nodes, clients) = LightningTestNodeBuilder::new(2).build_full();
+
+        let activity = test_utils::create_activity(nodes[0].clone(), nodes[1].clone(), 0);
+        let simulation = test_utils::create_simulation(clients, vec![activity]);
+        let result = simulation.validate_activity().await;
+
+        assert!(result.is_err());
+        assert!(matches!(result, 
+            Err(LightningError::ValidationError(msg)) if msg.contains("zero values")));
+    }
+
+    /// Verifies that validation fails with no nodes, expecting a `ValidationError` with
+    /// "we don't control any nodes".
+    #[tokio::test]
+    async fn test_validate_node_network_empty_nodes() {
+        let empty_nodes: HashMap<PublicKey, Arc<Mutex<dyn LightningNode>>> = HashMap::new();
+
+        let simulation = test_utils::create_simulation(empty_nodes, vec![]);
+        let result = simulation.validate_node_network().await;
+
+        assert!(result.is_err());
+        assert!(matches!(result, 
+            Err(LightningError::ValidationError(msg)) if msg.contains("we don't control any nodes")));
+    }
+
+    /// Verifies that a node on Bitcoin mainnet fails validation, expecting a `ValidationError`
+    /// with "mainnet is not supported".
+    #[tokio::test]
+    async fn test_validate_node_network_mainnet_not_supported() {
+        let clients = LightningTestNodeBuilder::new(1)
+            .with_networks(vec![Network::Bitcoin])
+            .build_clients_only();
+
+        let simulation = test_utils::create_simulation(clients, vec![]);
+        let result = simulation.validate_node_network().await;
+
+        assert!(result.is_err());
+        assert!(matches!(result, 
+            Err(LightningError::ValidationError(msg)) if msg.contains("mainnet is not supported")));
+    }
+
+    /// Verifies that nodes on Testnet and Regtest fail validation, expecting a
+    /// `ValidationError` with "nodes are not on the same network".
+    #[tokio::test]
+    async fn test_validate_node_network_mixed_networks() {
+        let clients = LightningTestNodeBuilder::new(2)
+            .with_networks(vec![Network::Testnet, Network::Regtest])
+            .build_clients_only();
+
+        let simulation = test_utils::create_simulation(clients, vec![]);
+        let result = simulation.validate_node_network().await;
+
+        assert!(result.is_err());
+        assert!(matches!(result, 
+            Err(LightningError::ValidationError(msg)) if msg.contains("nodes are not on the same network")));
+    }
+
+    /// Verifies that three Testnet nodes pass validation, expecting an `Ok` result.
+    #[tokio::test]
+    async fn test_validate_node_network_multiple_nodes_same_network() {
+        let clients = LightningTestNodeBuilder::new(3)
+            .with_networks(vec![Network::Testnet, Network::Testnet, Network::Testnet])
+            .build_clients_only();
+
+        let simulation = test_utils::create_simulation(clients, vec![]);
+        let result = simulation.validate_node_network().await;
+
+        assert!(result.is_ok());
+    }
+
+    #[tokio::test]
+    async fn test_validate_node_network_single_node_valid_network() {
+        let clients = LightningTestNodeBuilder::new(1)
+            .with_networks(vec![Network::Testnet])
+            .build_clients_only();
+
+        let simulation = test_utils::create_simulation(clients, vec![]);
+        let result = simulation.validate_node_network().await;
+
+        assert!(result.is_ok());
     }
 }