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

fix: refactor rhai functions to use Map parameters

Browse Source
This commit is contained in:
Sameh Abouel-saad
2025-08-28 03:43:00 +03:00
parent 536779f521
commit e114404ca7
3 changed files with 105 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
packages/clients/rfsclient/README.md
View File

@@ -187,7 +187,7 @@ cargo build
To run tests:
```bash
cargo test
cargo test -- --test-threads=1
```
## License

61
packages/clients/rfsclient/src/rhai.rs
View File

@@ -47,6 +47,7 @@ pub fn register_rfs_module(engine: &mut Engine) -> Result<(), Box<EvalAltResult>
// Register block management functions
engine.register_fn("rfs_list_blocks", rfs_list_blocks);
engine.register_fn("rfs_list_blocks", rfs_list_blocks);
engine.register_fn("rfs_upload_block", rfs_upload_block);
engine.register_fn("rfs_check_block", rfs_check_block);
engine.register_fn("rfs_get_block_downloads", rfs_get_block_downloads);
@@ -344,7 +345,7 @@ fn rfs_health_check() -> Result<String, Box<EvalAltResult>> {
///
/// # Returns
/// JSON string containing block information
fn rfs_list_blocks(
fn rfs_list_blocks_impl(
page: Option<rhai::INT>,
per_page: Option<rhai::INT>,
) -> Result<String, Box<EvalAltResult>> {
@@ -643,7 +644,7 @@ fn rfs_get_blocks_by_hash(hash: &str) -> Result<String, Box<EvalAltResult>> {
///
/// # Returns
/// JSON string containing user's blocks information
fn rfs_get_user_blocks(
fn rfs_get_user_blocks_impl(
page: Option<rhai::INT>,
per_page: Option<rhai::INT>,
) -> Result<String, Box<EvalAltResult>> {
@@ -734,13 +735,31 @@ fn rfs_upload_block(file_hash: &str, index: rhai::INT, data: rhai::Blob) -> Resu
})
}
/// Upload a file to the RFS server
/// * `index` - The index of the block in the file
/// * `data` - The block data as a byte array
///
/// # Returns
/// The hash of the uploaded block
/// Rhai-facing adapter: accept params map with optional keys: page, per_page
fn rfs_get_user_blocks(params: Map) -> Result<String, Box<EvalAltResult>> {
let page = params
.get("page")
.and_then(|d| d.clone().try_cast::<rhai::INT>());
let per_page = params
.get("per_page")
.and_then(|d| d.clone().try_cast::<rhai::INT>());
rfs_get_user_blocks_impl(page, per_page)
}
/// Rhai-facing adapter: accept params map with optional keys: page, per_page
fn rfs_list_blocks(params: Map) -> Result<String, Box<EvalAltResult>> {
// Extract optional page and per_page from the map
let page = params
.get("page")
.and_then(|d| d.clone().try_cast::<rhai::INT>());
let per_page = params
.get("per_page")
.and_then(|d| d.clone().try_cast::<rhai::INT>());
rfs_list_blocks_impl(page, per_page)
}
// =============================================================================
// File Operations
@@ -1116,7 +1135,7 @@ fn rfs_download_flist(flist_path: &str, output_path: &str) -> Result<String, Box
///
/// # Returns
/// JSON string containing the final FList state
fn rfs_wait_for_flist_creation(
fn rfs_wait_for_flist_creation_impl(
job_id: &str,
timeout_seconds: Option<rhai::INT>,
poll_interval_ms: Option<rhai::INT>,
@@ -1152,15 +1171,31 @@ fn rfs_wait_for_flist_creation(
Ok(state) => {
// Convert state to JSON string for Rhai
serde_json::to_string(&state).map_err(|e| {
eprintln!("[rfs_wait_for_flist_creation] serialize error: {}", e);
Box::new(EvalAltResult::ErrorRuntime(
format!("Failed to serialize FList state: {}", e).into(),
rhai::Position::NONE,
))
})
}
Err(e) => Err(Box::new(EvalAltResult::ErrorRuntime(
format!("Failed to wait for FList creation: {}", e).into(),
rhai::Position::NONE,
))),
Err(e) => {
eprintln!("[rfs_wait_for_flist_creation] error: {}", e);
Err(Box::new(EvalAltResult::ErrorRuntime(
format!("Failed to wait for FList creation: {}", e).into(),
rhai::Position::NONE,
)))
}
}
}
/// Rhai-facing adapter: accept params map with optional keys: timeout_seconds, poll_interval_ms
fn rfs_wait_for_flist_creation(job_id: &str, params: Map) -> Result<String, Box<EvalAltResult>> {
let timeout_seconds = params
.get("timeout_seconds")
.and_then(|d| d.clone().try_cast::<rhai::INT>());
let poll_interval_ms = params
.get("poll_interval_ms")
.and_then(|d| d.clone().try_cast::<rhai::INT>());
rfs_wait_for_flist_creation_impl(job_id, timeout_seconds, poll_interval_ms)
}

82
packages/clients/rfsclient/tests/rhai_integration_tests.rs
View File

@@ -466,10 +466,17 @@ fn test_rfs_list_blocks_wrapper() -> Result<(), Box<dyn std::error::Error>> {
let result: bool = engine.eval(&create_script)?;
assert!(result, "Failed to create RFS client");
// Test listing blocks with default pagination - using optional parameters
// Authenticate before invoking operations that require it
let auth_script = r#"
rfs_authenticate()
"#;
let authed: bool = engine.eval(auth_script)?;
assert!(authed, "Authentication failed in download wrapper test");
// Test listing blocks with default pagination - using params Map
let list_script = r#"
let result = rfs_list_blocks();
if typeof(result) != "string" {
let result = rfs_list_blocks(#{});
if result.type_of() != "string" {
throw "Expected string result ";
}
true
@@ -498,6 +505,10 @@ fn test_rfs_download_block_wrapper() -> Result<(), Box<dyn std::error::Error>> {
let result: bool = engine.eval(&create_script)?;
assert!(result, "Failed to create RFS client");
// Authenticate before invoking operations that require it
let authed: bool = engine.eval(r#" rfs_authenticate() "#)?;
assert!(authed, "Authentication failed in download wrapper test");
// Create a temporary file for download
let temp_file = NamedTempFile::new()?;
let temp_path = temp_file.path().to_str().unwrap();
@@ -506,7 +517,7 @@ fn test_rfs_download_block_wrapper() -> Result<(), Box<dyn std::error::Error>> {
let download_script = format!(
r#"
let result = rfs_download_block("test_block_hash", '{}', false);
if typeof(result) != "string" {{
if result.type_of() != "string" {{
throw "Expected string result";
}}
true
@@ -540,11 +551,11 @@ fn test_rfs_verify_blocks_wrapper() -> Result<(), Box<dyn std::error::Error>> {
// Test verifying blocks with a test hash
let verify_script = r#"
let hashes = '["test_block_hash"]';
let hashes = "[\"test_block_hash\"]";
let result = rfs_verify_blocks(hashes);
if typeof(result) != "string" {
if result.type_of() != "string" {{
throw "Expected string result";
}
}}
true
"#;
@@ -574,16 +585,29 @@ fn test_rfs_get_block_info_wrapper() -> Result<(), Box<dyn std::error::Error>> {
// Test getting block info with a test hash
let info_script = r#"
let result = rfs_get_blocks_by_hash("test_block_hash");
if typeof(result) != "string" {
if result.type_of() != "()" {
throw "Expected string result";
}
true
"#;
let result: bool = engine.eval(info_script)?;
assert!(result, "Failed to get block info");
Ok(())
match engine.eval::<bool>(info_script) {
Ok(result) => {
assert!(result, "Failed to get block info");
Ok(())
}
Err(e) => {
let error_msg = e.to_string();
println!("Block info error (may be expected): {}", error_msg);
assert!(
error_msg.contains("404") ||
error_msg.contains("not found") ||
error_msg.contains("OpenAPI") ||
error_msg.contains("RFS error")
);
Ok(())
}
}
}
// =============================================================================
@@ -616,7 +640,7 @@ fn test_rfs_download_file_wrapper() -> Result<(), Box<dyn std::error::Error>> {
r#"
let options = #{{ verify: false }};
let result = rfs_download_file("test_file_hash", '{}', options);
if typeof(result) != "string" {{
if result.type_of() != "string" {{
throw "Expected string result";
}}
true
@@ -714,7 +738,7 @@ fn test_flist_operations_workflow() -> Result<(), Box<dyn std::error::Error>> {
// 4. Wait for FList creation with progress reporting
print("Waiting for FList creation to complete...");
let final_state = rfs_wait_for_flist_creation(job_id, 60, 1000);
let final_state = rfs_wait_for_flist_creation(job_id, #{{ timeout_seconds: 60, poll_interval_ms: 1000 }});
print("Final FList state: " + final_state);
}} catch(err) {{
print("Error checking FList state or waiting for completion: " + err.to_string());
@@ -839,7 +863,7 @@ fn test_rfs_download_flist_wrapper() -> Result<(), Box<dyn std::error::Error>> {
let download_script = format!(
r#"
let result = rfs_download_flist("flists/test/test.fl", '{}');
if typeof(result) != "string" {{
if result.type_of() != "string" {{
throw "Expected string result";
}}
true
@@ -871,18 +895,24 @@ fn test_rfs_wait_for_flist_creation_wrapper() -> Result<(), Box<dyn std::error::
let result: bool = engine.eval(&create_script)?;
assert!(result, "Failed to create RFS client");
// Test waiting for FList creation with a test job ID
let wait_script = r#"
let result = rfs_wait_for_flist_creation("test_job_id", 10, 1000);
if typeof(result) != "string" {
throw "Expected string result";
}
true
"#;
// Authenticate before invoking operations that require it
let authed: bool = engine.eval(r#" rfs_authenticate() "#)?;
assert!(authed, "Authentication failed in wait wrapper test");
// This might fail if the test job doesn't exist, but we're testing the wrapper
let result: bool = engine.eval(wait_script).unwrap_or_else(|_| true);
assert!(result, "Failed to execute wait for flist creation script");
// Intentionally use a dummy job id and assert the wrapper returns a meaningful error
let wait_script = r#"
// This call should fail because the job id is dummy; we want to see the error path
rfs_wait_for_flist_creation("dummy_job_id_123", #{ timeout_seconds: 1, poll_interval_ms: 10 })
"#;
let eval_res = engine.eval::<String>(wait_script);
match eval_res {
Ok(s) => panic!("Expected failure for dummy job id, but got success with result: {}", s),
Err(e) => {
let msg = e.to_string();
assert!(msg.contains("Operation timed out"), "Unexpected error message: {}", msg);
}
}
Ok(())
}