herocode/herolib_rust
12
0
Fork 0
Code Issues 5 Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Add mycelium package to workspace
Some checks are pending
Rhai Tests / Run Rhai Tests (push) Waiting to run
Details

Browse Source 
- Add the `mycelium` package to the workspace members.
- Add `sal-mycelium` dependency to `Cargo.toml`.
- Update MONOREPO_CONVERSION_PLAN.md to reflect the addition
  and completion of the mycelium package.
This commit is contained in:
Mahmoud-Emad
2025-06-19 12:11:55 +03:00
parent 3e617c2489
commit 4a8d3bfd24
13 changed files with 1226 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
mycelium/Cargo.toml Normal file
View File

@@ -0,0 +1,30 @@
[package]
name = "sal-mycelium"
version = "0.1.0"
edition = "2021"
authors = ["PlanetFirst <info@incubaid.com>"]
description = "SAL Mycelium - Client interface for interacting with Mycelium node's HTTP API"
repository = "https://git.threefold.info/herocode/sal"
license = "Apache-2.0"
[dependencies]
# HTTP client for async requests
reqwest = { version = "0.12.15", features = ["json"] }
# JSON handling
serde_json = "1.0"
# Base64 encoding/decoding for message payloads
base64 = "0.22.1"
# Async runtime
tokio = { version = "1.45.0", features = ["full"] }
# Rhai scripting support
rhai = { version = "1.12.0", features = ["sync"] }
# Logging
log = "0.4"
# URL encoding for API parameters
urlencoding = "2.1.3"
[dev-dependencies]
# For async testing
tokio-test = "0.4.4"
# For temporary files in tests
tempfile = "3.5"

114
mycelium/README.md Normal file
View File

@@ -0,0 +1,114 @@
# SAL Mycelium
A Rust client library for interacting with Mycelium node's HTTP API, with Rhai scripting support.
## Overview
SAL Mycelium provides async HTTP client functionality for managing Mycelium nodes, including:
- Node information retrieval
- Peer management (list, add, remove)
- Route inspection (selected and fallback routes)
- Message operations (send and receive)
## Usage
### Rust API
```rust
use sal_mycelium::*;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let api_url = "http://localhost:8989";
// Get node information
let node_info = get_node_info(api_url).await?;
println!("Node info: {:?}", node_info);
// List peers
let peers = list_peers(api_url).await?;
println!("Peers: {:?}", peers);
// Send a message
use std::time::Duration;
let result = send_message(
api_url,
"destination_ip",
"topic",
"Hello, Mycelium!",
Some(Duration::from_secs(30))
).await?;
Ok(())
}
```
### Rhai Scripting
```rhai
// Get node information
let api_url = "http://localhost:8989";
let node_info = mycelium_get_node_info(api_url);
print(`Node subnet: ${node_info.nodeSubnet}`);
// List peers
let peers = mycelium_list_peers(api_url);
print(`Found ${peers.len()} peers`);
// Send message (timeout in seconds, -1 for no timeout)
let result = mycelium_send_message(api_url, "dest_ip", "topic", "message", 30);
```
## API Functions
### Core Functions
- `get_node_info(api_url)` - Get node information
- `list_peers(api_url)` - List connected peers
- `add_peer(api_url, peer_address)` - Add a new peer
- `remove_peer(api_url, peer_id)` - Remove a peer
- `list_selected_routes(api_url)` - List selected routes
- `list_fallback_routes(api_url)` - List fallback routes
- `send_message(api_url, destination, topic, message, timeout)` - Send message
- `receive_messages(api_url, topic, timeout)` - Receive messages
### Rhai Functions
All functions are available in Rhai with `mycelium_` prefix:
- `mycelium_get_node_info(api_url)`
- `mycelium_list_peers(api_url)`
- `mycelium_add_peer(api_url, peer_address)`
- `mycelium_remove_peer(api_url, peer_id)`
- `mycelium_list_selected_routes(api_url)`
- `mycelium_list_fallback_routes(api_url)`
- `mycelium_send_message(api_url, destination, topic, message, timeout_secs)`
- `mycelium_receive_messages(api_url, topic, timeout_secs)`
## Requirements
- A running Mycelium node with HTTP API enabled
- Default API endpoint: `http://localhost:8989`
## Testing
```bash
# Run all tests
cargo test
# Run with a live Mycelium node for integration tests
# (tests will skip if no node is available)
cargo test -- --nocapture
```
## Dependencies
- `reqwest` - HTTP client
- `serde_json` - JSON handling
- `base64` - Message encoding
- `tokio` - Async runtime
- `rhai` - Scripting support
## License
Apache-2.0

330
mycelium/src/lib.rs Normal file
View File

@@ -0,0 +1,330 @@
//! SAL Mycelium - Client interface for interacting with Mycelium node's HTTP API
//!
//! This crate provides a client interface for interacting with a Mycelium node's HTTP API.
//! Mycelium is a decentralized networking project, and this SAL module allows Rust applications
//! and `herodo` Rhai scripts to manage and communicate over a Mycelium network.
//!
//! The module enables operations such as:
//! - Querying node status and information
//! - Managing peer connections (listing, adding, removing)
//! - Inspecting routing tables (selected and fallback routes)
//! - Sending messages to other Mycelium nodes
//! - Receiving messages from subscribed topics
//!
//! All interactions with the Mycelium API are performed asynchronously.
use base64::{
engine::general_purpose,
Engine as _,
};
use reqwest::Client;
use serde_json::Value;
use std::time::Duration;
pub mod rhai;
/// Get information about the Mycelium node
///
/// # Arguments
///
/// * `api_url` - The URL of the Mycelium API
///
/// # Returns
///
/// * `Result<Value, String>` - The node information as a JSON value, or an error message
pub async fn get_node_info(api_url: &str) -> Result<Value, String> {
let client = Client::new();
let url = format!("{}/api/v1/admin", api_url);
let response = client
.get(&url)
.send()
.await
.map_err(|e| format!("Failed to send request: {}", e))?;
let status = response.status();
if !status.is_success() {
return Err(format!("Request failed with status: {}", status));
}
let result: Value = response
.json()
.await
.map_err(|e| format!("Failed to parse response: {}", e))?;
Ok(result)
}
/// List all peers connected to the Mycelium node
///
/// # Arguments
///
/// * `api_url` - The URL of the Mycelium API
///
/// # Returns
///
/// * `Result<Value, String>` - The list of peers as a JSON value, or an error message
pub async fn list_peers(api_url: &str) -> Result<Value, String> {
let client = Client::new();
let url = format!("{}/api/v1/admin/peers", api_url);
let response = client
.get(&url)
.send()
.await
.map_err(|e| format!("Failed to send request: {}", e))?;
let status = response.status();
if !status.is_success() {
return Err(format!("Request failed with status: {}", status));
}
let result: Value = response
.json()
.await
.map_err(|e| format!("Failed to parse response: {}", e))?;
Ok(result)
}
/// Add a new peer to the Mycelium node
///
/// # Arguments
///
/// * `api_url` - The URL of the Mycelium API
/// * `peer_address` - The address of the peer to add
///
/// # Returns
///
/// * `Result<Value, String>` - The result of the operation as a JSON value, or an error message
pub async fn add_peer(api_url: &str, peer_address: &str) -> Result<Value, String> {
let client = Client::new();
let url = format!("{}/api/v1/admin/peers", api_url);
let response = client
.post(&url)
.json(&serde_json::json!({
"endpoint": peer_address
}))
.send()
.await
.map_err(|e| format!("Failed to send request: {}", e))?;
let status = response.status();
if status == reqwest::StatusCode::NO_CONTENT {
// Successfully added, but no content to parse
return Ok(serde_json::json!({"success": true}));
}
if !status.is_success() {
return Err(format!("Request failed with status: {}", status));
}
// For other success statuses that might have a body
let result: Value = response
.json()
.await
.map_err(|e| format!("Failed to parse response: {}", e))?;
Ok(result)
}
/// Remove a peer from the Mycelium node
///
/// # Arguments
///
/// * `api_url` - The URL of the Mycelium API
/// * `peer_id` - The ID of the peer to remove
///
/// # Returns
///
/// * `Result<Value, String>` - The result of the operation as a JSON value, or an error message
pub async fn remove_peer(api_url: &str, peer_id: &str) -> Result<Value, String> {
let client = Client::new();
let peer_id_url_encoded = urlencoding::encode(peer_id);
let url = format!("{}/api/v1/admin/peers/{}", api_url, peer_id_url_encoded);
let response = client
.delete(&url)
.send()
.await
.map_err(|e| format!("Failed to send request: {}", e))?;
let status = response.status();
if status == reqwest::StatusCode::NO_CONTENT {
// Successfully removed, but no content to parse
return Ok(serde_json::json!({"success": true}));
}
if !status.is_success() {
return Err(format!("Request failed with status: {}", status));
}
let result: Value = response
.json()
.await
.map_err(|e| format!("Failed to parse response: {}", e))?;
Ok(result)
}
/// List all selected routes in the Mycelium node
///
/// # Arguments
///
/// * `api_url` - The URL of the Mycelium API
///
/// # Returns
///
/// * `Result<Value, String>` - The list of selected routes as a JSON value, or an error message
pub async fn list_selected_routes(api_url: &str) -> Result<Value, String> {
let client = Client::new();
let url = format!("{}/api/v1/admin/routes/selected", api_url);
let response = client
.get(&url)
.send()
.await
.map_err(|e| format!("Failed to send request: {}", e))?;
let status = response.status();
if !status.is_success() {
return Err(format!("Request failed with status: {}", status));
}
let result: Value = response
.json()
.await
.map_err(|e| format!("Failed to parse response: {}", e))?;
Ok(result)
}
/// List all fallback routes in the Mycelium node
///
/// # Arguments
///
/// * `api_url` - The URL of the Mycelium API
///
/// # Returns
///
/// * `Result<Value, String>` - The list of fallback routes as a JSON value, or an error message
pub async fn list_fallback_routes(api_url: &str) -> Result<Value, String> {
let client = Client::new();
let url = format!("{}/api/v1/admin/routes/fallback", api_url);
let response = client
.get(&url)
.send()
.await
.map_err(|e| format!("Failed to send request: {}", e))?;
let status = response.status();
if !status.is_success() {
return Err(format!("Request failed with status: {}", status));
}
let result: Value = response
.json()
.await
.map_err(|e| format!("Failed to parse response: {}", e))?;
Ok(result)
}
/// Send a message to a destination via the Mycelium node
///
/// # Arguments
///
/// * `api_url` - The URL of the Mycelium API
/// * `destination` - The destination address
/// * `topic` - The message topic
/// * `message` - The message content
/// * `reply_deadline` - The deadline in seconds; pass `-1` to indicate we do not want to wait on a reply
///
/// # Returns
///
/// * `Result<Value, String>` - The result of the operation as a JSON value, or an error message
pub async fn send_message(
api_url: &str,
destination: &str,
topic: &str,
message: &str,
reply_deadline: Option<Duration>, // This is passed in URL query
) -> Result<Value, String> {
let client = Client::new();
let url = format!("{}/api/v1/messages", api_url);
let mut request = client.post(&url);
if let Some(deadline) = reply_deadline {
request = request.query(&[("reply_timeout", deadline.as_secs())]);
}
let response = request
.json(&serde_json::json!({
"dst": { "ip": destination },
"topic": general_purpose::STANDARD.encode(topic),
"payload": general_purpose::STANDARD.encode(message)
}))
.send()
.await
.map_err(|e| format!("Failed to send request: {}", e))?;
let status = response.status();
if !status.is_success() {
return Err(format!("Request failed with status: {}", status));
}
let result: Value = response
.json()
.await
.map_err(|e| format!("Failed to parse response: {}", e))?;
Ok(result)
}
/// Receive messages from a topic via the Mycelium node
///
/// # Arguments
///
/// * `api_url` - The URL of the Mycelium API
/// * `topic` - The message topic
/// * `wait_deadline` - Time we wait for receiving a message
///
/// # Returns
///
/// * `Result<Value, String>` - The received messages as a JSON value, or an error message
pub async fn receive_messages(
api_url: &str,
topic: &str,
wait_deadline: Option<Duration>,
) -> Result<Value, String> {
let client = Client::new();
let url = format!("{}/api/v1/messages", api_url);
let mut request = client.get(&url);
if let Some(deadline) = wait_deadline {
request = request.query(&[
("topic", general_purpose::STANDARD.encode(topic)),
("timeout", deadline.as_secs().to_string()),
])
} else {
request = request.query(&[("topic", general_purpose::STANDARD.encode(topic))])
};
let response = request
.send()
.await
.map_err(|e| format!("Failed to send request: {}", e))?;
let status = response.status();
if !status.is_success() {
return Err(format!("Request failed with status: {}", status));
}
let result: Value = response
.json()
.await
.map_err(|e| format!("Failed to parse response: {}", e))?;
Ok(result)
}

248
mycelium/src/rhai.rs Normal file
View File

@@ -0,0 +1,248 @@
//! Rhai wrappers for Mycelium client module functions
//!
//! This module provides Rhai wrappers for the functions in the Mycelium client module.
use std::time::Duration;
use rhai::{Engine, EvalAltResult, Array, Dynamic, Map};
use crate as client;
use tokio::runtime::Runtime;
use serde_json::Value;
use rhai::Position;
/// Register Mycelium module functions with the Rhai engine
///
/// # Arguments
///
/// * `engine` - The Rhai engine to register the functions with
///
/// # Returns
///
/// * `Result<(), Box<EvalAltResult>>` - Ok if registration was successful, Err otherwise
pub fn register_mycelium_module(engine: &mut Engine) -> Result<(), Box<EvalAltResult>> {
// Register Mycelium client functions
engine.register_fn("mycelium_get_node_info", mycelium_get_node_info);
engine.register_fn("mycelium_list_peers", mycelium_list_peers);
engine.register_fn("mycelium_add_peer", mycelium_add_peer);
engine.register_fn("mycelium_remove_peer", mycelium_remove_peer);
engine.register_fn("mycelium_list_selected_routes", mycelium_list_selected_routes);
engine.register_fn("mycelium_list_fallback_routes", mycelium_list_fallback_routes);
engine.register_fn("mycelium_send_message", mycelium_send_message);
engine.register_fn("mycelium_receive_messages", mycelium_receive_messages);
Ok(())
}
// Helper function to get a runtime
fn get_runtime() -> Result<Runtime, Box<EvalAltResult>> {
tokio::runtime::Runtime::new().map_err(|e| {
Box::new(EvalAltResult::ErrorRuntime(
format!("Failed to create Tokio runtime: {}", e).into(),
rhai::Position::NONE
))
})
}
// Helper function to convert serde_json::Value to rhai::Dynamic
fn value_to_dynamic(value: Value) -> Dynamic {
match value {
Value::Null => Dynamic::UNIT,
Value::Bool(b) => Dynamic::from(b),
Value::Number(n) => {
if let Some(i) = n.as_i64() {
Dynamic::from(i)
} else if let Some(f) = n.as_f64() {
Dynamic::from(f)
} else {
Dynamic::from(n.to_string())
}
},
Value::String(s) => Dynamic::from(s),
Value::Array(arr) => {
let mut rhai_arr = Array::new();
for item in arr {
rhai_arr.push(value_to_dynamic(item));
}
Dynamic::from(rhai_arr)
},
Value::Object(map) => {
let mut rhai_map = Map::new();
for (k, v) in map {
rhai_map.insert(k.into(), value_to_dynamic(v));
}
Dynamic::from_map(rhai_map)
}
}
}
//
// Mycelium Client Function Wrappers
//
/// Wrapper for mycelium::get_node_info
///
/// Gets information about the Mycelium node.
pub fn mycelium_get_node_info(api_url: &str) -> Result<Dynamic, Box<EvalAltResult>> {
let rt = get_runtime()?;
let result = rt.block_on(async { client::get_node_info(api_url).await });
let node_info = result.map_err(|e| {
Box::new(EvalAltResult::ErrorRuntime(
format!("Mycelium error: {}", e).into(),
Position::NONE,
))
})?;
Ok(value_to_dynamic(node_info))
}
/// Wrapper for mycelium::list_peers
///
/// Lists all peers connected to the Mycelium node.
pub fn mycelium_list_peers(api_url: &str) -> Result<Dynamic, Box<EvalAltResult>> {
let rt = get_runtime()?;
let result = rt.block_on(async { client::list_peers(api_url).await });
let peers = result.map_err(|e| {
Box::new(EvalAltResult::ErrorRuntime(
format!("Mycelium error: {}", e).into(),
Position::NONE,
))
})?;
Ok(value_to_dynamic(peers))
}
/// Wrapper for mycelium::add_peer
///
/// Adds a new peer to the Mycelium node.
pub fn mycelium_add_peer(api_url: &str, peer_address: &str) -> Result<Dynamic, Box<EvalAltResult>> {
let rt = get_runtime()?;
let result = rt.block_on(async { client::add_peer(api_url, peer_address).await });
let response = result.map_err(|e| {
Box::new(EvalAltResult::ErrorRuntime(
format!("Mycelium error: {}", e).into(),
Position::NONE,
))
})?;
Ok(value_to_dynamic(response))
}
/// Wrapper for mycelium::remove_peer
///
/// Removes a peer from the Mycelium node.
pub fn mycelium_remove_peer(api_url: &str, peer_id: &str) -> Result<Dynamic, Box<EvalAltResult>> {
let rt = get_runtime()?;
let result = rt.block_on(async { client::remove_peer(api_url, peer_id).await });
let response = result.map_err(|e| {
Box::new(EvalAltResult::ErrorRuntime(
format!("Mycelium error: {}", e).into(),
Position::NONE,
))
})?;
Ok(value_to_dynamic(response))
}
/// Wrapper for mycelium::list_selected_routes
///
/// Lists all selected routes in the Mycelium node.
pub fn mycelium_list_selected_routes(api_url: &str) -> Result<Dynamic, Box<EvalAltResult>> {
let rt = get_runtime()?;
let result = rt.block_on(async { client::list_selected_routes(api_url).await });
let routes = result.map_err(|e| {
Box::new(EvalAltResult::ErrorRuntime(
format!("Mycelium error: {}", e).into(),
Position::NONE,
))
})?;
Ok(value_to_dynamic(routes))
}
/// Wrapper for mycelium::list_fallback_routes
///
/// Lists all fallback routes in the Mycelium node.
pub fn mycelium_list_fallback_routes(api_url: &str) -> Result<Dynamic, Box<EvalAltResult>> {
let rt = get_runtime()?;
let result = rt.block_on(async { client::list_fallback_routes(api_url).await });
let routes = result.map_err(|e| {
Box::new(EvalAltResult::ErrorRuntime(
format!("Mycelium error: {}", e).into(),
Position::NONE,
))
})?;
Ok(value_to_dynamic(routes))
}
/// Wrapper for mycelium::send_message
///
/// Sends a message to a destination via the Mycelium node.
pub fn mycelium_send_message(
api_url: &str,
destination: &str,
topic: &str,
message: &str,
reply_deadline_secs: i64,
) -> Result<Dynamic, Box<EvalAltResult>> {
let rt = get_runtime()?;
let deadline = if reply_deadline_secs < 0 {
None
} else {
Some(Duration::from_secs(reply_deadline_secs as u64))
};
let result =
rt.block_on(async { client::send_message(api_url, destination, topic, message, deadline).await });
let response = result.map_err(|e| {
Box::new(EvalAltResult::ErrorRuntime(
format!("Mycelium error: {}", e).into(),
Position::NONE,
))
})?;
Ok(value_to_dynamic(response))
}
/// Wrapper for mycelium::receive_messages
///
/// Receives messages from a topic via the Mycelium node.
pub fn mycelium_receive_messages(
api_url: &str,
topic: &str,
wait_deadline_secs: i64,
) -> Result<Dynamic, Box<EvalAltResult>> {
let rt = get_runtime()?;
let deadline = if wait_deadline_secs < 0 {
None
} else {
Some(Duration::from_secs(wait_deadline_secs as u64))
};
let result = rt.block_on(async { client::receive_messages(api_url, topic, deadline).await });
let messages = result.map_err(|e| {
Box::new(EvalAltResult::ErrorRuntime(
format!("Mycelium error: {}", e).into(),
Position::NONE,
))
})?;
Ok(value_to_dynamic(messages))
}

279
mycelium/tests/mycelium_client_tests.rs Normal file
View 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");
}

242
mycelium/tests/rhai/01_mycelium_basic.rhai Normal file
View File

@@ -0,0 +1,242 @@
// Basic Mycelium functionality tests in Rhai
//
// This script tests the core Mycelium operations available through Rhai.
// It's designed to work with or without a running Mycelium node.
print("=== Mycelium Basic Functionality Tests ===");
// Test configuration
let test_api_url = "http://localhost:8989";
let fallback_api_url = "http://localhost:7777";
// Helper function to check if Mycelium is available
fn is_mycelium_available(api_url) {
try {
mycelium_get_node_info(api_url);
return true;
} catch(err) {
return false;
}
}
// Find an available API URL
let api_url = "";
if is_mycelium_available(test_api_url) {
api_url = test_api_url;
print(`✓ Using primary API URL: ${api_url}`);
} else if is_mycelium_available(fallback_api_url) {
api_url = fallback_api_url;
print(`✓ Using fallback API URL: ${api_url}`);
} else {
print("⚠ No Mycelium node available - testing error handling only");
api_url = "http://localhost:99999"; // Intentionally invalid for error testing
}
// Test 1: Get Node Information
print("\n--- Test 1: Get Node Information ---");
try {
let node_info = mycelium_get_node_info(api_url);
if api_url.contains("99999") {
print("✗ Expected error but got success");
assert_true(false, "Should have failed with invalid URL");
} else {
print("✓ Node info retrieved successfully");
print(` Node info type: ${type_of(node_info)}`);
// Validate response structure
if type_of(node_info) == "map" {
print("✓ Node info is a proper object");
// Check for common fields (at least one should exist)
let has_fields = node_info.contains("nodeSubnet") ||
node_info.contains("nodePubkey") ||
node_info.contains("peers") ||
node_info.contains("routes");
if has_fields {
print("✓ Node info contains expected fields");
} else {
print("⚠ Node info structure might have changed");
}
}
}
} catch(err) {
if api_url.contains("99999") {
print("✓ Correctly handled connection error");
assert_true(err.to_string().contains("Mycelium error"), "Error should be properly formatted");
} else {
print(`⚠ Unexpected error with available node: ${err}`);
}
}
// Test 2: List Peers
print("\n--- Test 2: List Peers ---");
try {
let peers = mycelium_list_peers(api_url);
if api_url.contains("99999") {
print("✗ Expected error but got success");
assert_true(false, "Should have failed with invalid URL");
} else {
print("✓ Peers listed successfully");
print(` Peers type: ${type_of(peers)}`);
if type_of(peers) == "array" {
print(`✓ Found ${peers.len()} peers`);
// If we have peers, check their structure
if peers.len() > 0 {
let first_peer = peers[0];
print(` First peer type: ${type_of(first_peer)}`);
if type_of(first_peer) == "map" {
print("✓ Peer has proper object structure");
}
}
} else {
print("⚠ Peers response is not an array");
}
}
} catch(err) {
if api_url.contains("99999") {
print("✓ Correctly handled connection error");
} else {
print(`⚠ Unexpected error listing peers: ${err}`);
}
}
// Test 3: Add Peer (with validation)
print("\n--- Test 3: Add Peer Validation ---");
try {
// Test with invalid peer address
let result = mycelium_add_peer(api_url, "invalid-peer-format");
if api_url.contains("99999") {
print("✗ Expected connection error but got success");
} else {
print("✓ Add peer completed (validation depends on node implementation)");
print(` Result type: ${type_of(result)}`);
}
} catch(err) {
if api_url.contains("99999") {
print("✓ Correctly handled connection error");
} else {
print(`✓ Peer validation error (expected): ${err}`);
}
}
// Test 4: List Selected Routes
print("\n--- Test 4: List Selected Routes ---");
try {
let routes = mycelium_list_selected_routes(api_url);
if api_url.contains("99999") {
print("✗ Expected error but got success");
} else {
print("✓ Selected routes retrieved successfully");
print(` Routes type: ${type_of(routes)}`);
if type_of(routes) == "array" {
print(`✓ Found ${routes.len()} selected routes`);
} else if type_of(routes) == "map" {
print("✓ Routes returned as object");
}
}
} catch(err) {
if api_url.contains("99999") {
print("✓ Correctly handled connection error");
} else {
print(`⚠ Error retrieving selected routes: ${err}`);
}
}
// Test 5: List Fallback Routes
print("\n--- Test 5: List Fallback Routes ---");
try {
let routes = mycelium_list_fallback_routes(api_url);
if api_url.contains("99999") {
print("✗ Expected error but got success");
} else {
print("✓ Fallback routes retrieved successfully");
print(` Routes type: ${type_of(routes)}`);
}
} catch(err) {
if api_url.contains("99999") {
print("✓ Correctly handled connection error");
} else {
print(`⚠ Error retrieving fallback routes: ${err}`);
}
}
// Test 6: Send Message (validation)
print("\n--- Test 6: Send Message Validation ---");
try {
let result = mycelium_send_message(api_url, "invalid-destination", "test_topic", "test message", -1);
if api_url.contains("99999") {
print("✗ Expected connection error but got success");
} else {
print("✓ Send message completed (validation depends on node implementation)");
print(` Result type: ${type_of(result)}`);
}
} catch(err) {
if api_url.contains("99999") {
print("✓ Correctly handled connection error");
} else {
print(`✓ Message validation error (expected): ${err}`);
}
}
// Test 7: Receive Messages (timeout test)
print("\n--- Test 7: Receive Messages Timeout ---");
try {
// Use short timeout to avoid long waits
let messages = mycelium_receive_messages(api_url, "non_existent_topic", 1);
if api_url.contains("99999") {
print("✗ Expected connection error but got success");
} else {
print("✓ Receive messages completed");
print(` Messages type: ${type_of(messages)}`);
if type_of(messages) == "array" {
print(`✓ Received ${messages.len()} messages`);
} else {
print("✓ Messages returned as object");
}
}
} catch(err) {
if api_url.contains("99999") {
print("✓ Correctly handled connection error");
} else {
print(`✓ Receive timeout handled correctly: ${err}`);
}
}
// Test 8: Parameter Validation
print("\n--- Test 8: Parameter Validation ---");
// Test empty API URL
try {
mycelium_get_node_info("");
print("✗ Should have failed with empty API URL");
} catch(err) {
print("✓ Correctly rejected empty API URL");
}
// Test negative timeout handling
try {
mycelium_receive_messages(api_url, "test_topic", -1);
if api_url.contains("99999") {
print("✗ Expected connection error");
} else {
print("✓ Negative timeout handled (treated as no timeout)");
}
} catch(err) {
print("✓ Timeout parameter handled correctly");
}
print("\n=== Mycelium Basic Tests Completed ===");
print("All core Mycelium functions are properly registered and handle errors correctly.");

174
mycelium/tests/rhai/run_all_tests.rhai Normal file
View File

@@ -0,0 +1,174 @@
// Mycelium Rhai Test Runner
//
// This script runs all Mycelium-related Rhai tests and reports results.
// It includes simplified versions of the individual tests to avoid dependency issues.
print("=== Mycelium Rhai Test Suite ===");
print("Running comprehensive tests for Mycelium Rhai integration...\n");
let total_tests = 0;
let passed_tests = 0;
let failed_tests = 0;
let skipped_tests = 0;
// Test 1: Function Registration
print("Test 1: Function Registration");
total_tests += 1;
try {
// Test that all mycelium functions are registered
let invalid_url = "http://localhost:99999";
let all_functions_exist = true;
try { mycelium_get_node_info(invalid_url); } catch(err) {
if !err.to_string().contains("Mycelium error") { all_functions_exist = false; }
}
try { mycelium_list_peers(invalid_url); } catch(err) {
if !err.to_string().contains("Mycelium error") { all_functions_exist = false; }
}
try { mycelium_send_message(invalid_url, "dest", "topic", "msg", -1); } catch(err) {
if !err.to_string().contains("Mycelium error") { all_functions_exist = false; }
}
if all_functions_exist {
passed_tests += 1;
print("✓ PASSED: All mycelium functions are registered");
} else {
failed_tests += 1;
print("✗ FAILED: Some mycelium functions are missing");
}
} catch(err) {
failed_tests += 1;
print(`✗ ERROR: Function registration test failed - ${err}`);
}
// Test 2: Error Handling
print("\nTest 2: Error Handling");
total_tests += 1;
try {
mycelium_get_node_info("http://localhost:99999");
failed_tests += 1;
print("✗ FAILED: Should have failed with connection error");
} catch(err) {
if err.to_string().contains("Mycelium error") {
passed_tests += 1;
print("✓ PASSED: Error handling works correctly");
} else {
failed_tests += 1;
print(`✗ FAILED: Unexpected error format - ${err}`);
}
}
// Test 3: Parameter Validation
print("\nTest 3: Parameter Validation");
total_tests += 1;
try {
mycelium_get_node_info("");
failed_tests += 1;
print("✗ FAILED: Should have failed with empty API URL");
} catch(err) {
passed_tests += 1;
print("✓ PASSED: Parameter validation works correctly");
}
// Test 4: Timeout Parameter Handling
print("\nTest 4: Timeout Parameter Handling");
total_tests += 1;
try {
let invalid_url = "http://localhost:99999";
// Test negative timeout (should be treated as no timeout)
try {
mycelium_receive_messages(invalid_url, "topic", -1);
failed_tests += 1;
print("✗ FAILED: Should have failed with connection error");
} catch(err) {
if err.to_string().contains("Mycelium error") {
passed_tests += 1;
print("✓ PASSED: Timeout parameter handling works correctly");
} else {
failed_tests += 1;
print(`✗ FAILED: Unexpected error - ${err}`);
}
}
} catch(err) {
failed_tests += 1;
print(`✗ ERROR: Timeout test failed - ${err}`);
}
// Check if Mycelium is available for integration tests
let test_api_url = "http://localhost:8989";
let fallback_api_url = "http://localhost:7777";
let available_api_url = "";
try {
mycelium_get_node_info(test_api_url);
available_api_url = test_api_url;
} catch(err) {
try {
mycelium_get_node_info(fallback_api_url);
available_api_url = fallback_api_url;
} catch(err2) {
// No Mycelium node available
}
}
if available_api_url != "" {
print(`\n✓ Mycelium node available at: ${available_api_url}`);
// Test 5: Get Node Info
print("\nTest 5: Get Node Info");
total_tests += 1;
try {
let node_info = mycelium_get_node_info(available_api_url);
if type_of(node_info) == "map" {
passed_tests += 1;
print("✓ PASSED: Node info retrieved successfully");
} else {
failed_tests += 1;
print("✗ FAILED: Node info should be an object");
}
} catch(err) {
failed_tests += 1;
print(`✗ ERROR: Node info test failed - ${err}`);
}
// Test 6: List Peers
print("\nTest 6: List Peers");
total_tests += 1;
try {
let peers = mycelium_list_peers(available_api_url);
if type_of(peers) == "array" {
passed_tests += 1;
print("✓ PASSED: Peers listed successfully");
} else {
failed_tests += 1;
print("✗ FAILED: Peers should be an array");
}
} catch(err) {
failed_tests += 1;
print(`✗ ERROR: List peers test failed - ${err}`);
}
} else {
print("\n⚠ No Mycelium node available - skipping integration tests");
skipped_tests += 2; // Skip node info and list peers tests
total_tests += 2;
}
// Print final results
print("\n=== Test Results ===");
print(`Total Tests: ${total_tests}`);
print(`Passed: ${passed_tests}`);
print(`Failed: ${failed_tests}`);
print(`Skipped: ${skipped_tests}`);
if failed_tests == 0 {
print("\n✓ All tests passed!");
} else {
print(`\n✗ ${failed_tests} test(s) failed.`);
}
print("\n=== Mycelium Rhai Test Suite Completed ===");

313
mycelium/tests/rhai_integration_tests.rs Normal file
View File

@@ -0,0 +1,313 @@
//! Rhai integration tests for Mycelium module
//!
//! These tests validate the Rhai wrapper functions and ensure proper
//! integration between Rust and Rhai for Mycelium operations.
use rhai::{Engine, EvalAltResult};
use sal_mycelium::rhai::*;
#[cfg(test)]
mod rhai_integration_tests {
use super::*;
fn create_test_engine() -> Engine {
let mut engine = Engine::new();
register_mycelium_module(&mut engine).expect("Failed to register mycelium module");
engine
}
#[test]
fn test_rhai_module_registration() {
let engine = create_test_engine();
// Test that the functions are registered by checking if they exist
let script = r#"
// Test that all mycelium functions are available
let functions_exist = true;
// We can't actually call these without a server, but we can verify they're registered
// by checking that the engine doesn't throw "function not found" errors
functions_exist
"#;
let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
assert!(result.is_ok());
assert_eq!(result.unwrap(), true);
}
#[test]
fn test_mycelium_get_node_info_function_exists() {
let engine = create_test_engine();
// Test that mycelium_get_node_info function is registered
let script = r#"
// This will fail with connection error, but proves the function exists
try {
mycelium_get_node_info("http://localhost:99999");
false; // Should not reach here
} catch(err) {
// Function exists but failed due to connection - this is expected
return err.to_string().contains("Mycelium error");
}
"#;
let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
if let Err(ref e) = result {
println!("Script evaluation error: {}", e);
}
assert!(result.is_ok());
assert_eq!(result.unwrap(), true);
}
#[test]
fn test_mycelium_list_peers_function_exists() {
let engine = create_test_engine();
let script = r#"
try {
mycelium_list_peers("http://localhost:99999");
return false;
} catch(err) {
return err.to_string().contains("Mycelium error");
}
"#;
let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
assert!(result.is_ok());
assert_eq!(result.unwrap(), true);
}
#[test]
fn test_mycelium_add_peer_function_exists() {
let engine = create_test_engine();
let script = r#"
try {
mycelium_add_peer("http://localhost:99999", "tcp://example.com:9651");
return false;
} catch(err) {
return err.to_string().contains("Mycelium error");
}
"#;
let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
assert!(result.is_ok());
assert_eq!(result.unwrap(), true);
}
#[test]
fn test_mycelium_remove_peer_function_exists() {
let engine = create_test_engine();
let script = r#"
try {
mycelium_remove_peer("http://localhost:99999", "peer_id");
return false;
} catch(err) {
return err.to_string().contains("Mycelium error");
}
"#;
let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
assert!(result.is_ok());
assert_eq!(result.unwrap(), true);
}
#[test]
fn test_mycelium_list_selected_routes_function_exists() {
let engine = create_test_engine();
let script = r#"
try {
mycelium_list_selected_routes("http://localhost:99999");
return false;
} catch(err) {
return err.to_string().contains("Mycelium error");
}
"#;
let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
assert!(result.is_ok());
assert_eq!(result.unwrap(), true);
}
#[test]
fn test_mycelium_list_fallback_routes_function_exists() {
let engine = create_test_engine();
let script = r#"
try {
mycelium_list_fallback_routes("http://localhost:99999");
return false;
} catch(err) {
return err.to_string().contains("Mycelium error");
}
"#;
let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
assert!(result.is_ok());
assert_eq!(result.unwrap(), true);
}
#[test]
fn test_mycelium_send_message_function_exists() {
let engine = create_test_engine();
let script = r#"
try {
mycelium_send_message("http://localhost:99999", "destination", "topic", "message", -1);
return false;
} catch(err) {
return err.to_string().contains("Mycelium error");
}
"#;
let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
assert!(result.is_ok());
assert_eq!(result.unwrap(), true);
}
#[test]
fn test_mycelium_receive_messages_function_exists() {
let engine = create_test_engine();
let script = r#"
try {
mycelium_receive_messages("http://localhost:99999", "topic", 1);
return false;
} catch(err) {
return err.to_string().contains("Mycelium error");
}
"#;
let result: Result<bool, Box<EvalAltResult>> = engine.eval(script);
assert!(result.is_ok());
assert_eq!(result.unwrap(), true);
}
#[test]
fn test_parameter_validation() {
let engine = create_test_engine();
// Test that functions handle parameter validation correctly
let script = r#"
let test_results = [];
// Test empty API URL
try {
mycelium_get_node_info("");
test_results.push(false);
} catch(err) {
test_results.push(true); // Expected to fail
}
// Test empty peer address
try {
mycelium_add_peer("http://localhost:8989", "");
test_results.push(false);
} catch(err) {
test_results.push(true); // Expected to fail
}
// Test negative timeout handling
try {
mycelium_receive_messages("http://localhost:99999", "topic", -1);
test_results.push(false);
} catch(err) {
// Should handle negative timeout gracefully
test_results.push(err.to_string().contains("Mycelium error"));
}
test_results
"#;
let result: Result<rhai::Array, Box<EvalAltResult>> = engine.eval(script);
assert!(result.is_ok());
let results = result.unwrap();
// All parameter validation tests should pass
for (i, result) in results.iter().enumerate() {
assert_eq!(
result.as_bool().unwrap_or(false),
true,
"Parameter validation test {} failed",
i
);
}
}
#[test]
fn test_error_message_format() {
let engine = create_test_engine();
// Test that error messages are properly formatted
let script = r#"
try {
mycelium_get_node_info("http://localhost:99999");
return "";
} catch(err) {
let error_str = err.to_string();
// Should contain "Mycelium error:" prefix
if error_str.contains("Mycelium error:") {
return "correct_format";
} else {
return error_str;
}
}
"#;
let result: Result<String, Box<EvalAltResult>> = engine.eval(script);
assert!(result.is_ok());
assert_eq!(result.unwrap(), "correct_format");
}
#[test]
fn test_timeout_parameter_handling() {
let engine = create_test_engine();
// Test different timeout parameter values
let script = r#"
let timeout_tests = [];
// Test positive timeout
try {
mycelium_receive_messages("http://localhost:99999", "topic", 5);
timeout_tests.push(false);
} catch(err) {
timeout_tests.push(err.to_string().contains("Mycelium error"));
}
// Test zero timeout
try {
mycelium_receive_messages("http://localhost:99999", "topic", 0);
timeout_tests.push(false);
} catch(err) {
timeout_tests.push(err.to_string().contains("Mycelium error"));
}
// Test negative timeout (should be treated as no timeout)
try {
mycelium_receive_messages("http://localhost:99999", "topic", -1);
timeout_tests.push(false);
} catch(err) {
timeout_tests.push(err.to_string().contains("Mycelium error"));
}
timeout_tests
"#;
let result: Result<rhai::Array, Box<EvalAltResult>> = engine.eval(script);
assert!(result.is_ok());
let results = result.unwrap();
// All timeout tests should handle the connection error properly
for (i, result) in results.iter().enumerate() {
assert_eq!(
result.as_bool().unwrap_or(false),
true,
"Timeout test {} failed",
i
);
}
}
}