...
This commit is contained in:
279
packages/clients/myceliumclient/tests/mycelium_client_tests.rs
Normal file
279
packages/clients/myceliumclient/tests/mycelium_client_tests.rs
Normal file
@@ -0,0 +1,279 @@
|
||||
//! Unit tests for Mycelium client functionality
|
||||
//!
|
||||
//! These tests validate the core Mycelium client operations including:
|
||||
//! - Node information retrieval
|
||||
//! - Peer management (listing, adding, removing)
|
||||
//! - Route inspection (selected and fallback routes)
|
||||
//! - Message operations (sending and receiving)
|
||||
//!
|
||||
//! Tests are designed to work with a real Mycelium node when available,
|
||||
//! but gracefully handle cases where the node is not accessible.
|
||||
|
||||
use sal_mycelium::*;
|
||||
use std::time::Duration;
|
||||
|
||||
/// Test configuration for Mycelium API
|
||||
const TEST_API_URL: &str = "http://localhost:8989";
|
||||
const FALLBACK_API_URL: &str = "http://localhost:7777";
|
||||
|
||||
/// Helper function to check if a Mycelium node is available
|
||||
async fn is_mycelium_available(api_url: &str) -> bool {
|
||||
match get_node_info(api_url).await {
|
||||
Ok(_) => true,
|
||||
Err(_) => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Helper function to get an available Mycelium API URL
|
||||
async fn get_available_api_url() -> Option<String> {
|
||||
if is_mycelium_available(TEST_API_URL).await {
|
||||
Some(TEST_API_URL.to_string())
|
||||
} else if is_mycelium_available(FALLBACK_API_URL).await {
|
||||
Some(FALLBACK_API_URL.to_string())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_get_node_info_success() {
|
||||
if let Some(api_url) = get_available_api_url().await {
|
||||
let result = get_node_info(&api_url).await;
|
||||
|
||||
match result {
|
||||
Ok(node_info) => {
|
||||
// Validate that we got a JSON response with expected fields
|
||||
assert!(node_info.is_object(), "Node info should be a JSON object");
|
||||
|
||||
// Check for common Mycelium node info fields
|
||||
let obj = node_info.as_object().unwrap();
|
||||
|
||||
// These fields are typically present in Mycelium node info
|
||||
// We check if at least one of them exists to validate the response
|
||||
let has_expected_fields = obj.contains_key("nodeSubnet")
|
||||
|| obj.contains_key("nodePubkey")
|
||||
|| obj.contains_key("peers")
|
||||
|| obj.contains_key("routes");
|
||||
|
||||
assert!(
|
||||
has_expected_fields,
|
||||
"Node info should contain expected Mycelium fields"
|
||||
);
|
||||
println!("✓ Node info retrieved successfully: {:?}", node_info);
|
||||
}
|
||||
Err(e) => {
|
||||
// If we can connect but get an error, it might be a version mismatch
|
||||
// or API change - log it but don't fail the test
|
||||
println!("⚠ Node info request failed (API might have changed): {}", e);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
println!("⚠ Skipping test_get_node_info_success: No Mycelium node available");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_get_node_info_invalid_url() {
|
||||
let invalid_url = "http://localhost:99999";
|
||||
let result = get_node_info(invalid_url).await;
|
||||
|
||||
assert!(result.is_err(), "Should fail with invalid URL");
|
||||
let error = result.unwrap_err();
|
||||
assert!(
|
||||
error.contains("Failed to send request") || error.contains("Request failed"),
|
||||
"Error should indicate connection failure: {}",
|
||||
error
|
||||
);
|
||||
println!("✓ Correctly handled invalid URL: {}", error);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_list_peers() {
|
||||
if let Some(api_url) = get_available_api_url().await {
|
||||
let result = list_peers(&api_url).await;
|
||||
|
||||
match result {
|
||||
Ok(peers) => {
|
||||
// Peers should be an array (even if empty)
|
||||
assert!(peers.is_array(), "Peers should be a JSON array");
|
||||
println!(
|
||||
"✓ Peers listed successfully: {} peers found",
|
||||
peers.as_array().unwrap().len()
|
||||
);
|
||||
}
|
||||
Err(e) => {
|
||||
println!(
|
||||
"⚠ List peers request failed (API might have changed): {}",
|
||||
e
|
||||
);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
println!("⚠ Skipping test_list_peers: No Mycelium node available");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_add_peer_validation() {
|
||||
if let Some(api_url) = get_available_api_url().await {
|
||||
// Test with an invalid peer address format
|
||||
let invalid_peer = "invalid-peer-address";
|
||||
let result = add_peer(&api_url, invalid_peer).await;
|
||||
|
||||
// This should either succeed (if the node accepts it) or fail with a validation error
|
||||
match result {
|
||||
Ok(response) => {
|
||||
println!("✓ Add peer response: {:?}", response);
|
||||
}
|
||||
Err(e) => {
|
||||
// Expected for invalid peer addresses
|
||||
println!("✓ Correctly rejected invalid peer address: {}", e);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
println!("⚠ Skipping test_add_peer_validation: No Mycelium node available");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_list_selected_routes() {
|
||||
if let Some(api_url) = get_available_api_url().await {
|
||||
let result = list_selected_routes(&api_url).await;
|
||||
|
||||
match result {
|
||||
Ok(routes) => {
|
||||
// Routes should be an array or object
|
||||
assert!(
|
||||
routes.is_array() || routes.is_object(),
|
||||
"Routes should be a JSON array or object"
|
||||
);
|
||||
println!("✓ Selected routes retrieved successfully");
|
||||
}
|
||||
Err(e) => {
|
||||
println!("⚠ List selected routes request failed: {}", e);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
println!("⚠ Skipping test_list_selected_routes: No Mycelium node available");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_list_fallback_routes() {
|
||||
if let Some(api_url) = get_available_api_url().await {
|
||||
let result = list_fallback_routes(&api_url).await;
|
||||
|
||||
match result {
|
||||
Ok(routes) => {
|
||||
// Routes should be an array or object
|
||||
assert!(
|
||||
routes.is_array() || routes.is_object(),
|
||||
"Routes should be a JSON array or object"
|
||||
);
|
||||
println!("✓ Fallback routes retrieved successfully");
|
||||
}
|
||||
Err(e) => {
|
||||
println!("⚠ List fallback routes request failed: {}", e);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
println!("⚠ Skipping test_list_fallback_routes: No Mycelium node available");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_send_message_validation() {
|
||||
if let Some(api_url) = get_available_api_url().await {
|
||||
// Test message sending with invalid destination
|
||||
let invalid_destination = "invalid-destination";
|
||||
let topic = "test_topic";
|
||||
let message = "test message";
|
||||
let deadline = Some(Duration::from_secs(1));
|
||||
|
||||
let result = send_message(&api_url, invalid_destination, topic, message, deadline).await;
|
||||
|
||||
// This should fail with invalid destination
|
||||
match result {
|
||||
Ok(response) => {
|
||||
// Some implementations might accept any destination format
|
||||
println!("✓ Send message response: {:?}", response);
|
||||
}
|
||||
Err(e) => {
|
||||
// Expected for invalid destinations
|
||||
println!("✓ Correctly rejected invalid destination: {}", e);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
println!("⚠ Skipping test_send_message_validation: No Mycelium node available");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_receive_messages_timeout() {
|
||||
if let Some(api_url) = get_available_api_url().await {
|
||||
let topic = "non_existent_topic";
|
||||
let deadline = Some(Duration::from_secs(1)); // Short timeout
|
||||
|
||||
let result = receive_messages(&api_url, topic, deadline).await;
|
||||
|
||||
match result {
|
||||
Ok(messages) => {
|
||||
// Should return empty or no messages for non-existent topic
|
||||
println!("✓ Receive messages completed: {:?}", messages);
|
||||
}
|
||||
Err(e) => {
|
||||
// Timeout or no messages is acceptable
|
||||
println!("✓ Receive messages handled correctly: {}", e);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
println!("⚠ Skipping test_receive_messages_timeout: No Mycelium node available");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_error_handling_malformed_url() {
|
||||
let malformed_url = "not-a-url";
|
||||
let result = get_node_info(malformed_url).await;
|
||||
|
||||
assert!(result.is_err(), "Should fail with malformed URL");
|
||||
let error = result.unwrap_err();
|
||||
assert!(
|
||||
error.contains("Failed to send request"),
|
||||
"Error should indicate request failure: {}",
|
||||
error
|
||||
);
|
||||
println!("✓ Correctly handled malformed URL: {}", error);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_base64_encoding_in_messages() {
|
||||
// Test that our message functions properly handle base64 encoding
|
||||
// This is a unit test that doesn't require a running Mycelium node
|
||||
|
||||
let topic = "test/topic";
|
||||
let message = "Hello, Mycelium!";
|
||||
|
||||
// Test base64 encoding directly
|
||||
use base64::{engine::general_purpose, Engine as _};
|
||||
let encoded_topic = general_purpose::STANDARD.encode(topic);
|
||||
let encoded_message = general_purpose::STANDARD.encode(message);
|
||||
|
||||
assert!(
|
||||
!encoded_topic.is_empty(),
|
||||
"Encoded topic should not be empty"
|
||||
);
|
||||
assert!(
|
||||
!encoded_message.is_empty(),
|
||||
"Encoded message should not be empty"
|
||||
);
|
||||
|
||||
// Verify we can decode back
|
||||
let decoded_topic = general_purpose::STANDARD.decode(&encoded_topic).unwrap();
|
||||
let decoded_message = general_purpose::STANDARD.decode(&encoded_message).unwrap();
|
||||
|
||||
assert_eq!(String::from_utf8(decoded_topic).unwrap(), topic);
|
||||
assert_eq!(String::from_utf8(decoded_message).unwrap(), message);
|
||||
|
||||
println!("✓ Base64 encoding/decoding works correctly");
|
||||
}
|
||||
Reference in New Issue
Block a user