use std::collections::HashMap;
use std::path::{Path, PathBuf};
use super::builtin::{ExecHook, MoveHook, RenameHook, TouchHook};
use super::types::{DownloadStats, HookContext, PostDownloadHook};
use super::{HookConfig, HookManager};
use crate::request::request_group::{DownloadStatus, GroupId};
fn create_test_context(file_path: &Path) -> HookContext {
HookContext {
gid: GroupId::new(42),
file_path: file_path.to_path_buf(),
status: DownloadStatus::Complete,
stats: DownloadStats {
uploaded_bytes: 1024,
downloaded_bytes: 2048,
upload_speed: 100.0,
download_speed: 200.0,
elapsed_seconds: 10,
},
error: None,
}
}
#[tokio::test]
async fn test_move_hook_basic() {
let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
let src_file = temp_dir.path().join("test_file.txt");
tokio::fs::write(&src_file, b"test content")
.await
.expect("Failed to write test file");
let target_dir = temp_dir.path().join("target");
let hook = MoveHook::new(target_dir.clone(), false);
tokio::fs::create_dir_all(&target_dir)
.await
.expect("Failed to create target dir");
let context = create_test_context(&src_file);
assert!(hook.on_complete(&context).await.is_ok());
let moved_file = target_dir.join("test_file.txt");
assert!(
moved_file.exists(),
"File should be moved to target directory"
);
assert!(!src_file.exists(), "Source file should no longer exist");
}
#[tokio::test]
async fn test_move_hook_create_dirs() {
let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
let src_file = temp_dir.path().join("test_file.txt");
tokio::fs::write(&src_file, b"test content")
.await
.expect("Failed to write test file");
let target_dir = temp_dir.path().join("nested").join("deep").join("target");
let hook = MoveHook::new(target_dir.clone(), true);
let context = create_test_context(&src_file);
assert!(hook.on_complete(&context).await.is_ok());
let moved_file = target_dir.join("test_file.txt");
assert!(
moved_file.exists(),
"File should be moved to auto-created directory"
);
}
#[tokio::test]
async fn test_rename_hook_pattern_expansion() {
let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
let src_file = temp_dir.path().join("archive.tar.gz");
tokio::fs::write(&src_file, b"content")
.await
.expect("Failed to write test file");
let hook = RenameHook::new("%f.renamed".to_string());
let context = create_test_context(&src_file);
let expanded = hook.expand_pattern(&context);
assert!(
expanded.contains("archive.tar.gz.renamed"),
"Pattern should contain original filename"
);
assert!(hook.on_complete(&context).await.is_ok());
let renamed_file = temp_dir.path().join("archive.tar.gz.renamed");
assert!(
renamed_file.exists(),
"File should be renamed according to pattern"
);
}
#[tokio::test]
async fn test_touch_hook_updates_mtime() {
let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
let src_file = temp_dir.path().join("timestamp_test.txt");
tokio::fs::write(&src_file, b"touch test")
.await
.expect("Failed to write test file");
let before_metadata = tokio::fs::metadata(&src_file)
.await
.expect("Failed to get metadata");
let before_mtime = before_metadata.modified().expect("Failed to get mtime");
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
let hook = TouchHook::new();
let context = create_test_context(&src_file);
assert!(hook.on_complete(&context).await.is_ok());
let after_metadata = tokio::fs::metadata(&src_file)
.await
.expect("Failed to get metadata after touch");
let after_mtime = after_metadata
.modified()
.expect("Failed to get mtime after touch");
assert!(
after_mtime >= before_mtime,
"Modification time should be updated to current time (before: {:?}, after: {:?})",
before_mtime,
after_mtime
);
}
#[tokio::test]
async fn test_exec_hook_env_vars_injected() {
let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
let output_file = temp_dir.path().join("env_output.txt");
let cmd = format!("echo $ARIA2_GID > {}", output_file.display());
let mut env_vars = HashMap::new();
env_vars.insert("CUSTOM_VAR".to_string(), "custom_value".to_string());
let hook = ExecHook::new(cmd, env_vars);
let context = create_test_context(&temp_dir.path().join("dummy.txt"));
#[cfg(unix)]
{
let result = hook.on_complete(&context).await;
let _ = result;
}
let built_env = hook.build_env(&context, None);
assert_eq!(
built_env.get("ARIA2_GID").unwrap(),
"42",
"GID should be injected"
);
assert_eq!(
built_env.get("ARIA2_STATUS").unwrap(),
"complete",
"Status should be complete"
);
assert_eq!(
built_env.get("CUSTOM_VAR").unwrap(),
"custom_value",
"Custom var should be preserved"
);
assert_eq!(
built_env.get("ARIA2_DOWNLOADED_BYTES").unwrap(),
"2048",
"Download bytes should be correct"
);
}
#[tokio::test]
async fn test_exec_hook_nonzero_exit_code() {
let hook = ExecHook::new("exit 1".to_string(), HashMap::new());
let context = create_test_context(Path::new("/tmp/nonexistent"));
let result = hook.on_complete(&context).await;
assert!(result.is_err(), "Non-zero exit code should return error");
let err_msg = format!("{:?}", result.unwrap_err());
assert!(
err_msg.contains("failed")
|| err_msg.contains("exit code")
|| err_msg.contains("Failed")
|| err_msg.contains("execute"),
"Error message should indicate failure, got: {}",
err_msg
);
}
#[tokio::test]
async fn test_hook_chain_execution_order() {
let mut manager = HookManager::new(HookConfig::default());
manager.add_hook(Box::new(TouchHook));
manager.add_hook(Box::new(RenameHook::new("%f.copy".to_string())));
assert_eq!(manager.hook_count(), 2, "Should have 2 hooks registered");
let removed = manager.remove_hook("RenameHook");
assert!(removed.is_some(), "Should be able to remove RenameHook");
assert_eq!(
manager.hook_count(),
1,
"Should have 1 hook remaining after removal"
);
}
#[tokio::test]
async fn test_hook_failure_isolation() {
let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
let config = HookConfig {
stop_on_error: false,
..Default::default()
};
let mut manager = HookManager::new(config);
manager.add_hook(Box::new(ExecHook::new(
"exit 1".to_string(),
HashMap::new(),
)));
let context = create_test_context(&temp_dir.path().join("test.txt"));
let results = manager.fire_complete(&context).await;
assert!(results.is_ok(), "Should not fail when stop_on_error=false");
let results_vec = results.unwrap();
assert_eq!(results_vec.len(), 1, "Should have one result entry");
assert!(
results_vec[0].contains("failed"),
"Result should indicate failure of the first hook"
);
}
#[tokio::test]
async fn test_hook_config_stop_on_error() {
let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
let config = HookConfig {
stop_on_error: true,
..Default::default()
};
let mut manager = HookManager::new(config);
manager.add_hook(Box::new(ExecHook::new(
"exit 1".to_string(),
HashMap::new(),
)));
manager.add_hook(Box::new(ExecHook::new(
"echo success".to_string(),
HashMap::new(),
)));
let context = create_test_context(&temp_dir.path().join("test.txt"));
let result = manager.fire_complete(&context).await;
assert!(
result.is_err(),
"Should return error when stop_on_error=true and first hook fails"
);
}
#[tokio::test]
async fn test_hook_remove_by_name() {
let mut manager = HookManager::new(HookConfig::default());
manager.add_hook(Box::new(TouchHook));
manager.add_hook(Box::new(MoveHook::new(PathBuf::from("/tmp"), false)));
assert_eq!(manager.hook_count(), 2);
let removed = manager.remove_hook("TouchHook");
assert!(removed.is_some(), "Should find and remove TouchHook");
assert_eq!(removed.unwrap().name(), "TouchHook");
assert_eq!(manager.hook_count(), 1, "Should have 1 hook remaining");
let not_found = manager.remove_hook("NonExistentHook");
assert!(
not_found.is_none(),
"Should return None for non-existent hook"
);
}
#[test]
fn test_hook_context_creation() {
let context = HookContext::new(
GroupId::new(123),
PathBuf::from("/downloads/file.zip"),
DownloadStatus::Complete,
DownloadStats {
downloaded_bytes: 9999,
..Default::default()
},
None,
);
assert_eq!(context.gid.value(), 123);
assert_eq!(context.filename(), "file.zip");
assert_eq!(context.extension(), "zip");
assert_eq!(context.status, DownloadStatus::Complete);
assert!(context.error.is_none());
assert_eq!(context.stats.downloaded_bytes, 9999);
}
#[test]
fn test_download_stats_display() {
let stats = DownloadStats {
uploaded_bytes: 1024,
downloaded_bytes: 2048,
upload_speed: 100.5,
download_speed: 200.25,
elapsed_seconds: 30,
};
let display = format!("{}", stats);
assert!(
display.contains("downloaded=2048"),
"Should contain downloaded bytes"
);
assert!(
display.contains("uploaded=1024"),
"Should contain uploaded bytes"
);
assert!(display.contains("200.25"), "Should contain download speed");
assert!(
display.contains("elapsed=30s"),
"Should contain elapsed time"
);
}