254 lines
7.9 KiB
Rust
254 lines
7.9 KiB
Rust
//! Tests for Rhai integration
|
|
//!
|
|
//! This module contains tests for the Rhai integration.
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use rhai::Engine;
|
|
use super::super::register;
|
|
use std::fs;
|
|
use std::path::Path;
|
|
|
|
#[test]
|
|
fn test_register() {
|
|
let mut engine = Engine::new();
|
|
assert!(register(&mut engine).is_ok());
|
|
}
|
|
|
|
// OS Module Tests
|
|
|
|
#[test]
|
|
fn test_exist_function() {
|
|
let mut engine = Engine::new();
|
|
register(&mut engine).unwrap();
|
|
|
|
// Test with a file that definitely exists
|
|
let result = engine.eval::<bool>(r#"exist("Cargo.toml")"#).unwrap();
|
|
assert!(result);
|
|
|
|
// Test with a file that definitely doesn't exist
|
|
let result = engine.eval::<bool>(r#"exist("non_existent_file.xyz")"#).unwrap();
|
|
assert!(!result);
|
|
}
|
|
|
|
#[test]
|
|
fn test_mkdir_and_delete() {
|
|
let mut engine = Engine::new();
|
|
register(&mut engine).unwrap();
|
|
|
|
let test_dir = "test_rhai_dir";
|
|
|
|
// Clean up from previous test runs if necessary
|
|
if Path::new(test_dir).exists() {
|
|
fs::remove_dir_all(test_dir).unwrap();
|
|
}
|
|
|
|
// Create directory using Rhai
|
|
let script = format!(r#"mkdir("{}")"#, test_dir);
|
|
let result = engine.eval::<String>(&script).unwrap();
|
|
assert!(result.contains("Successfully created directory"));
|
|
assert!(Path::new(test_dir).exists());
|
|
|
|
// Delete directory using Rhai
|
|
let script = format!(r#"delete("{}")"#, test_dir);
|
|
let result = engine.eval::<String>(&script).unwrap();
|
|
assert!(result.contains("Successfully deleted directory"));
|
|
assert!(!Path::new(test_dir).exists());
|
|
}
|
|
|
|
#[test]
|
|
fn test_file_size() {
|
|
let mut engine = Engine::new();
|
|
register(&mut engine).unwrap();
|
|
|
|
// Create a test file
|
|
let test_file = "test_rhai_file.txt";
|
|
let test_content = "Hello, Rhai!";
|
|
fs::write(test_file, test_content).unwrap();
|
|
|
|
// Get file size using Rhai
|
|
let script = format!(r#"file_size("{}")"#, test_file);
|
|
let size = engine.eval::<i64>(&script).unwrap();
|
|
assert_eq!(size, test_content.len() as i64);
|
|
|
|
// Clean up
|
|
fs::remove_file(test_file).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn test_error_handling() {
|
|
let mut engine = Engine::new();
|
|
register(&mut engine).unwrap();
|
|
|
|
// Try to get the size of a non-existent file
|
|
let result = engine.eval::<i64>(r#"file_size("non_existent_file.xyz")"#);
|
|
assert!(result.is_err());
|
|
|
|
let err = result.unwrap_err();
|
|
let err_str = err.to_string();
|
|
println!("Error string: {}", err_str);
|
|
// The actual error message is "No files found matching..."
|
|
assert!(err_str.contains("No files found matching") ||
|
|
err_str.contains("File not found") ||
|
|
err_str.contains("File system error"));
|
|
}
|
|
|
|
// Process Module Tests
|
|
|
|
#[test]
|
|
fn test_which_function() {
|
|
let mut engine = Engine::new();
|
|
register(&mut engine).unwrap();
|
|
|
|
// Test with a command that definitely exists (like "ls" on Unix or "cmd" on Windows)
|
|
#[cfg(target_os = "windows")]
|
|
let cmd = "cmd";
|
|
|
|
#[cfg(any(target_os = "macos", target_os = "linux"))]
|
|
let cmd = "ls";
|
|
|
|
let script = format!(r#"which("{}")"#, cmd);
|
|
let result = engine.eval::<String>(&script).unwrap();
|
|
assert!(!result.is_empty());
|
|
|
|
// Test with a command that definitely doesn't exist
|
|
let script = r#"which("non_existent_command_xyz123")"#;
|
|
let result = engine.eval::<()>(&script).unwrap();
|
|
assert_eq!(result, ());
|
|
}
|
|
|
|
#[test]
|
|
fn test_run_with_options() {
|
|
let mut engine = Engine::new();
|
|
register(&mut engine).unwrap();
|
|
|
|
// Test running a command with custom options
|
|
#[cfg(target_os = "windows")]
|
|
let script = r#"
|
|
let options = new_run_options();
|
|
options["die"] = true;
|
|
options["silent"] = false;
|
|
options["log"] = true;
|
|
let result = run("echo Hello World", options);
|
|
result.success && result.stdout.contains("Hello World")
|
|
"#;
|
|
|
|
#[cfg(any(target_os = "macos", target_os = "linux"))]
|
|
let script = r#"
|
|
let options = new_run_options();
|
|
options["die"] = true;
|
|
options["silent"] = false;
|
|
options["log"] = true;
|
|
let result = run("echo 'Hello World'", options);
|
|
result.success && result.stdout.contains("Hello World")
|
|
"#;
|
|
|
|
let result = engine.eval::<bool>(script).unwrap();
|
|
assert!(result);
|
|
}
|
|
|
|
#[test]
|
|
fn test_run_command() {
|
|
let mut engine = Engine::new();
|
|
register(&mut engine).unwrap();
|
|
|
|
// Test a simple echo command
|
|
#[cfg(target_os = "windows")]
|
|
let script = r#"
|
|
let result = run_command("echo Hello World");
|
|
result.success && result.stdout.contains("Hello World")
|
|
"#;
|
|
|
|
#[cfg(any(target_os = "macos", target_os = "linux"))]
|
|
let script = r#"
|
|
let result = run_command("echo 'Hello World'");
|
|
result.success && result.stdout.contains("Hello World")
|
|
"#;
|
|
|
|
let result = engine.eval::<bool>(script).unwrap();
|
|
assert!(result);
|
|
}
|
|
|
|
#[test]
|
|
fn test_run_silent() {
|
|
let mut engine = Engine::new();
|
|
register(&mut engine).unwrap();
|
|
|
|
// Test a simple echo command with silent execution
|
|
#[cfg(target_os = "windows")]
|
|
let script = r#"
|
|
let result = run_silent("echo Hello World");
|
|
result.success && result.stdout.contains("Hello World")
|
|
"#;
|
|
|
|
#[cfg(any(target_os = "macos", target_os = "linux"))]
|
|
let script = r#"
|
|
let result = run_silent("echo 'Hello World'");
|
|
result.success && result.stdout.contains("Hello World")
|
|
"#;
|
|
|
|
let result = engine.eval::<bool>(script).unwrap();
|
|
assert!(result);
|
|
}
|
|
|
|
#[test]
|
|
fn test_process_list() {
|
|
let mut engine = Engine::new();
|
|
register(&mut engine).unwrap();
|
|
|
|
// Test listing processes (should return a non-empty array)
|
|
let script = r#"
|
|
let processes = process_list("");
|
|
processes.len() > 0
|
|
"#;
|
|
|
|
let result = engine.eval::<bool>(script).unwrap();
|
|
assert!(result);
|
|
}
|
|
|
|
// Git Module Tests
|
|
|
|
#[test]
|
|
fn test_git_module_registration() {
|
|
let mut engine = Engine::new();
|
|
register(&mut engine).unwrap();
|
|
|
|
// Test that git functions are registered
|
|
let script = r#"
|
|
// Check if git_clone function exists
|
|
let fn_exists = is_def_fn("git_clone");
|
|
fn_exists
|
|
"#;
|
|
|
|
let result = engine.eval::<bool>(script).unwrap();
|
|
assert!(result);
|
|
}
|
|
|
|
#[test]
|
|
fn test_git_parse_url() {
|
|
let mut engine = Engine::new();
|
|
register(&mut engine).unwrap();
|
|
|
|
// Test parsing a git URL
|
|
let script = r#"
|
|
// We can't directly test git_clone without actually cloning,
|
|
// but we can test that the function exists and doesn't error
|
|
// when called with invalid parameters
|
|
|
|
let result = false;
|
|
|
|
try {
|
|
// This should fail but not crash
|
|
git_clone("invalid-url");
|
|
} catch(err) {
|
|
// Expected error
|
|
result = err.contains("Git error");
|
|
}
|
|
|
|
result
|
|
"#;
|
|
|
|
let result = engine.eval::<bool>(script).unwrap();
|
|
assert!(result);
|
|
}
|
|
} |