feat(tests): Enhance routing and peer selection tests for improved coverage

- Refactored existing tests for better clarity and consistency, including renaming functions for better context.
- Added new tests for routing table retrieval, error handling with empty bundles, and best route selection with multiple costs.
- Implemented asynchronous tests for peer selection, ensuring only reachable peers are selected.
- Improved assertions in tests to validate expected outcomes more effectively.

These changes enhance the robustness of the testing framework, ensuring comprehensive coverage of routing and peer management functionalities.

Author: Ray-Gee

src/api/tests.rs

@@ -285,7 +285,8 @@ async fn test_find_best_route() -> anyhow::Result<()> {
 
     let best_route = node.find_best_route(&dest)?;
     assert!(best_route.is_some());
-    assert_eq!(best_route.unwrap().cost, 5); // Should be the cheaper route
+    let best = best_route.unwrap();
+    assert_eq!(best.cost, 5); // Should be the cheaper route
     Ok(())
 }
 
@@ -301,7 +302,7 @@ async fn test_find_best_route_no_routes() -> anyhow::Result<()> {
 }
 
 #[tokio::test]
-async fn test_select_peers_for_forwarding() -> anyhow::Result<()> {
+async fn api_test_select_peers_for_forwarding() -> anyhow::Result<()> {
     let temp_dir = TempDir::new()?;
     let node = DtnNode::with_store_path(temp_dir.path().to_str().unwrap())?;
 
@@ -485,7 +486,208 @@ async fn test_complex_routing_scenario() -> anyhow::Result<()> {
     let dest = EndpointId::from("dtn://dest");
     let best_route = node.find_best_route(&dest)?;
     assert!(best_route.is_some());
-    assert_eq!(best_route.unwrap().cost, 5); // Should be the cheapest
+    let best = best_route.unwrap();
+    assert_eq!(best.cost, 5); // Should be the cheapest
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_get_routing_table() -> anyhow::Result<()> {
+    let temp_dir = TempDir::new()?;
+    let node = DtnNode::with_store_path(temp_dir.path().to_str().unwrap())?;
+
+    // Test getting routing table reference
+    let routing_table = node.get_routing_table();
+
+    // Add a route through the reference
+    {
+        let mut table = routing_table.lock().unwrap();
+        table.add_route(RouteEntry {
+            destination: EndpointId::from("dtn://test-dest"),
+            next_hop: EndpointId::from("dtn://test-router"),
+            cla_type: "tcp".to_string(),
+            cost: 15,
+            is_active: true,
+        });
+    }
+
+    // Verify through node's get_all_routes
+    let routes = node.get_all_routes()?;
+    assert_eq!(routes.len(), 1);
+    assert_eq!(routes[0].destination.as_str(), "dtn://test-dest");
+    assert_eq!(routes[0].cost, 15);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn api_test_select_peers_for_forwarding_async() -> anyhow::Result<()> {
+    let temp_dir = TempDir::new()?;
+    let node = DtnNode::with_store_path(temp_dir.path().to_str().unwrap())?;
+
+    node.insert_bundle("Test async peer selection".to_string())
+        .await?;
+
+    let bundles = node.list_bundles()?;
+    let bundle_id = bundles.first().unwrap();
+    let bundle = node.show_bundle(bundle_id)?;
+
+    let peers = node.select_peers_for_forwarding_async(&bundle).await?;
+    assert_eq!(peers.len(), 0); // No reachable peers expected in this environment
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_error_handling_empty_bundle_list() -> anyhow::Result<()> {
+    let temp_dir = TempDir::new()?;
+    let node = DtnNode::with_store_path(temp_dir.path().to_str().unwrap())?;
+
+    // Test with empty bundle store
+    let bundles = node.list_bundles()?;
+    assert_eq!(bundles.len(), 0);
+
+    // Test status with no bundles
+    let status = node.get_bundle_status(None)?;
+    match status {
+        BundleStatus::Summary {
+            active,
+            expired,
+            total,
+        } => {
+            assert_eq!(active, 0);
+            assert_eq!(expired, 0);
+            assert_eq!(total, 0);
+        }
+        _ => panic!("Expected Summary status"),
+    }
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_show_bundle_nonexistent() -> anyhow::Result<()> {
+    let temp_dir = TempDir::new()?;
+    let node = DtnNode::with_store_path(temp_dir.path().to_str().unwrap())?;
+
+    // Test showing non-existent bundle
+    let result = node.show_bundle("nonexistent_bundle_id");
+    assert!(result.is_err());
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_find_best_route_multiple_costs() -> anyhow::Result<()> {
+    let temp_dir = TempDir::new()?;
+    let node = DtnNode::with_store_path(temp_dir.path().to_str().unwrap())?;
+
+    let dest = EndpointId::from("dtn://multi-cost");
+
+    // Add routes with different costs
+    node.add_route(RouteEntry {
+        destination: dest.clone(),
+        next_hop: EndpointId::from("dtn://expensive"),
+        cla_type: "tcp".to_string(),
+        cost: 100,
+        is_active: true,
+    })?;
+
+    node.add_route(RouteEntry {
+        destination: dest.clone(),
+        next_hop: EndpointId::from("dtn://medium"),
+        cla_type: "ble".to_string(),
+        cost: 50,
+        is_active: true,
+    })?;
+
+    node.add_route(RouteEntry {
+        destination: dest.clone(),
+        next_hop: EndpointId::from("dtn://cheap"),
+        cla_type: "lora".to_string(),
+        cost: 10,
+        is_active: true,
+    })?;
+
+    let best_route = node.find_best_route(&dest)?;
+    assert!(best_route.is_some());
+    let best = best_route.unwrap();
+    assert_eq!(best.cost, 10); // Should be the cheapest
+    assert_eq!(best.next_hop.as_str(), "dtn://cheap");
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_routing_config_varieties() -> anyhow::Result<()> {
+    use crate::routing::algorithm::{RoutingAlgorithmType, RoutingConfig};
+    let temp_dir = TempDir::new()?;
+
+    // Test with Epidemic routing
+    let epidemic_config = RoutingConfig::new(RoutingAlgorithmType::Epidemic);
+    let epidemic_node =
+        DtnNode::with_routing_algorithm(temp_dir.path().to_str().unwrap(), epidemic_config)?;
+
+    epidemic_node
+        .insert_bundle("Epidemic test".to_string())
+        .await?;
+    let bundles = epidemic_node.list_bundles()?;
+    assert_eq!(bundles.len(), 1);
+
+    // Test with Prophet routing (should fall back to epidemic)
+    let prophet_config = RoutingConfig::new(RoutingAlgorithmType::Prophet);
+    let prophet_node =
+        DtnNode::with_routing_algorithm(temp_dir.path().to_str().unwrap(), prophet_config)?;
+
+    prophet_node
+        .insert_bundle("Prophet fallback test".to_string())
+        .await?;
+    let bundles = prophet_node.list_bundles()?;
+    assert_eq!(bundles.len(), 2); // Same store as epidemic_node
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_bundle_status_with_partial_failures() -> anyhow::Result<()> {
+    let temp_dir = TempDir::new()?;
+    let node = DtnNode::with_store_path(temp_dir.path().to_str().unwrap())?;
+
+    // Insert valid bundles
+    node.insert_bundle("Valid bundle 1".to_string()).await?;
+    node.insert_bundle("Valid bundle 2".to_string()).await?;
+
+    let status = node.get_bundle_status(None)?;
+    match status {
+        BundleStatus::Summary {
+            active,
+            expired,
+            total,
+        } => {
+            assert_eq!(active, 2);
+            assert_eq!(expired, 0);
+            assert_eq!(total, 2);
+        }
+        _ => panic!("Expected Summary status"),
+    }
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_cleanup_expired_no_expired_bundles() -> anyhow::Result<()> {
+    let temp_dir = TempDir::new()?;
+    let node = DtnNode::with_store_path(temp_dir.path().to_str().unwrap())?;
+
+    // Insert fresh bundles (not expired)
+    node.insert_bundle("Fresh bundle".to_string()).await?;
+
+    // Cleanup should succeed without removing anything
+    node.cleanup_expired()?;
+
+    let bundles = node.list_bundles()?;
+    assert_eq!(bundles.len(), 1); // Bundle should still be there
 
     Ok(())
 }

src/cla/tests.rs

@@ -70,6 +70,7 @@ use crate::cla::manager::*;
 use crate::cla::tcp::client::*;
 use crate::cla::tcp::server::*;
 use crate::consts::tcp::*;
+use crate::routing::algorithm::ClaPeer;
 use async_trait::async_trait;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
@@ -953,3 +954,156 @@ fn test_create_test_bundle_various_payloads() {
         assert_eq!(bundle.payload, payload);
     }
 }
+
+// TcpPeer tests for better coverage
+#[test]
+fn test_tcp_peer_new() {
+    let eid = crate::bpv7::EndpointId::from("dtn://test-peer");
+    let peer = crate::cla::TcpPeer::new(eid.clone(), "192.168.1.100:8080".to_string());
+
+    assert_eq!(peer.peer_id, eid);
+    assert_eq!(peer.address, "192.168.1.100:8080");
+}
+
+#[test]
+fn test_tcp_peer_from_endpoint_id() {
+    let eid = crate::bpv7::EndpointId::from("dtn://test-node");
+    let peer = crate::cla::TcpPeer::from_endpoint_id(eid.clone());
+
+    assert_eq!(peer.peer_id, eid);
+    assert_eq!(peer.address, "dtn://test-node");
+}
+
+#[test]
+fn test_tcp_peer_for_test() {
+    let eid = crate::bpv7::EndpointId::from("dtn://test-endpoint");
+    let peer = crate::cla::TcpPeer::for_test(eid.clone());
+
+    assert_eq!(peer.peer_id, eid);
+    assert_eq!(peer.address, "dtn://test-endpoint");
+}
+
+#[test]
+fn test_tcp_peer_get_peer_endpoint_id() {
+    let eid = crate::bpv7::EndpointId::from("dtn://my-peer");
+    let peer = crate::cla::TcpPeer::new(eid.clone(), "10.0.0.1:9090".to_string());
+
+    assert_eq!(peer.get_peer_endpoint_id(), eid);
+}
+
+#[test]
+fn test_tcp_peer_get_cla_type() {
+    let eid = crate::bpv7::EndpointId::from("dtn://any-peer");
+    let peer = crate::cla::TcpPeer::new(eid, "localhost:8080".to_string());
+
+    assert_eq!(peer.get_cla_type(), "tcp");
+}
+
+#[test]
+fn test_tcp_peer_get_connection_address() {
+    let eid = crate::bpv7::EndpointId::from("dtn://addr-test");
+    let address = "example.com:1234".to_string();
+    let peer = crate::cla::TcpPeer::new(eid, address.clone());
+
+    assert_eq!(peer.get_connection_address(), address);
+}
+
+#[tokio::test]
+async fn test_tcp_peer_is_reachable_unreachable() {
+    let eid = crate::bpv7::EndpointId::from("dtn://unreachable");
+    let peer = crate::cla::TcpPeer::new(eid, "127.0.0.1:19998".to_string()); // Non-existent port
+
+    let reachable = peer.is_reachable().await;
+    assert!(!reachable);
+}
+
+#[tokio::test]
+async fn test_tcp_peer_is_reachable_timeout() {
+    let eid = crate::bpv7::EndpointId::from("dtn://timeout-test");
+    // Use a non-routable address that will cause timeout
+    let peer = crate::cla::TcpPeer::new(eid, "192.0.2.1:80".to_string()); // TEST-NET-1 (RFC 5737)
+
+    let reachable = peer.is_reachable().await;
+    assert!(!reachable);
+}
+
+#[tokio::test]
+async fn test_tcp_peer_is_reachable_with_mock_server() -> anyhow::Result<()> {
+    // Create a mock server to test successful connection
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await?;
+    let port = listener.local_addr()?.port();
+
+    // Start a server that accepts connections
+    tokio::spawn(async move {
+        if let Ok((stream, _)) = listener.accept().await {
+            drop(stream); // Just accept and close
+        }
+    });
+
+    let eid = crate::bpv7::EndpointId::from("dtn://reachable");
+    let peer = crate::cla::TcpPeer::new(eid, format!("127.0.0.1:{}", port));
+
+    // Give server time to start
+    tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
+
+    let reachable = peer.is_reachable().await;
+    assert!(reachable);
+
+    Ok(())
+}
+
+// Additional TcpClaClient tests
+#[test]
+fn test_tcp_cla_client_new() {
+    let client = TcpClaClient {
+        target_addr: "test.example.com:8080".to_string(),
+    };
+    assert_eq!(client.target_addr, "test.example.com:8080");
+}
+
+#[tokio::test]
+async fn test_tcp_cla_client_activate_connection_refused() {
+    let client = TcpClaClient {
+        target_addr: "127.0.0.1:19997".to_string(), // Non-existent server
+    };
+
+    let result = client.activate().await;
+    assert!(result.is_err());
+}
+
+#[tokio::test]
+async fn test_tcp_cla_client_activate_invalid_address() {
+    let client = TcpClaClient {
+        target_addr: "invalid-hostname:8080".to_string(),
+    };
+
+    let result = client.activate().await;
+    assert!(result.is_err());
+}
+
+// Test create_bundle function variations
+#[test]
+fn test_create_bundle_empty_payload() {
+    let bundle = create_bundle("dtn://src", "dtn://dst", vec![]);
+    assert_eq!(bundle.payload, b"");
+    assert_eq!(bundle.primary.source, "dtn://src");
+    assert_eq!(bundle.primary.destination, "dtn://dst");
+}
+
+#[test]
+fn test_create_bundle_large_payload() {
+    let large_payload = vec![0xFF; 1000];
+    let bundle = create_bundle("dtn://big-src", "dtn://big-dst", large_payload.clone());
+    assert_eq!(bundle.payload, large_payload);
+}
+
+#[test]
+fn test_create_bundle_unicode_addresses() {
+    let bundle = create_bundle(
+        "dtn://テスト送信",
+        "dtn://テスト受信",
+        b"unicode test".to_vec(),
+    );
+    assert_eq!(bundle.primary.source, "dtn://テスト送信");
+    assert_eq!(bundle.primary.destination, "dtn://テスト受信");
+}