use std::collections::HashMap;
use serde_json::Value;
use super::registry::OptionRegistry;
use super::types::{OptionCategory, OptionDef, OptionType, OptionValue};
use super::validator::{
ChoiceValidator, DependencyChecker, OptionDefinition, OptionError, OptionValidator,
RangeValidator, RegexValidator, UrlValidator,
};
#[test]
fn test_option_type_display() {
assert_eq!(OptionType::String.to_string(), "string");
assert_eq!(OptionType::Boolean.to_string(), "boolean");
assert_eq!(OptionType::PiecePriority.to_string(), "piece-priority");
assert_eq!(OptionType::Size.to_string(), "size");
}
#[test]
fn test_option_category_display() {
assert_eq!(OptionCategory::General.to_string(), "general");
assert_eq!(OptionCategory::BitTorrent.to_string(), "bittorrent");
}
#[test]
fn test_option_value_variants() {
let s = OptionValue::Str("hello".into());
assert_eq!(s.as_str().unwrap(), "hello");
let n = OptionValue::Int(42);
assert_eq!(n.as_i64().unwrap(), 42);
let b = OptionValue::Bool(true);
assert!(b.as_bool().unwrap());
let l = OptionValue::List(vec!["a".into(), "b".into()]);
assert_eq!(l.as_list().unwrap().len(), 2);
let none = OptionValue::None;
assert!(none.is_none());
}
#[test]
fn test_option_value_display() {
assert_eq!(OptionValue::Str("test".into()).to_string(), "test");
assert_eq!(OptionValue::Int(99).to_string(), "99");
assert_eq!(OptionValue::Bool(true).to_string(), "true");
assert_eq!(
OptionValue::List(vec!["x".into(), "y".into()]).to_string(),
"x,y"
);
}
#[test]
fn test_option_value_to_json() {
let v = OptionValue::Str("hello".into());
let jv: serde_json::Value = (&v).into();
assert_eq!(jv, "hello");
let v2 = OptionValue::Int(123);
let jv2: serde_json::Value = (&v2).into();
assert_eq!(jv2, 123);
let v3 = OptionValue::Bool(false);
let jv3: serde_json::Value = (&v3).into();
assert_eq!(jv3, false);
let v4 = OptionValue::List(vec!["a".into()]);
let jv4: serde_json::Value = (&v4).into();
assert!(jv4.is_array());
}
#[test]
fn test_option_value_from_json() {
let ov: OptionValue = serde_json::json!("test string").into();
assert_eq!(ov.as_str().unwrap(), "test string");
let ov2: OptionValue = serde_json::json!(42).into();
assert_eq!(ov2.as_i64().unwrap(), 42);
let ov3: OptionValue = serde_json::json!(true).into();
assert!(ov3.as_bool().unwrap());
let ov4: OptionValue = serde_json::json!(["a", "b"]).into();
assert_eq!(ov4.as_list().unwrap().len(), 2);
}
#[test]
fn test_size_parsing() {
assert_eq!(OptionValue::parse_size_str("100"), 100);
assert_eq!(OptionValue::parse_size_str("1K"), 1024);
assert_eq!(OptionValue::parse_size_str("2M"), 2 * 1024 * 1024);
assert_eq!(OptionValue::parse_size_str("1G"), 1024u64 * 1024 * 1024);
assert_eq!(OptionValue::parse_size_str("0"), 0);
}
#[test]
fn test_size_display() {
assert!(OptionValue::to_size_string(500).contains("500"));
assert!(OptionValue::to_size_string(2048).contains("K"));
assert!(OptionValue::to_size_string(3 * 1024 * 1024).contains("M"));
}
#[test]
fn test_option_def_builder() {
let def = OptionDef {
name: "split".into(),
opt_type: OptionType::Integer,
short_name: Some('s'),
default_value: OptionValue::Int(16),
description: "Concurrent segment requests per download".into(),
min: Some(1),
max: Some(128),
category: OptionCategory::HttpFtp,
..Default::default()
};
assert_eq!(def.name(), "split");
assert_eq!(def.short_name(), Some('s'));
assert_eq!(def.opt_type(), OptionType::Integer);
assert!(!def.is_deprecated());
assert!(!def.is_hidden());
}
#[test]
fn test_rpc_basic_auth_options_match_original_deprecation_metadata() {
let registry = OptionRegistry::new();
assert!(registry.get("rpc-user").unwrap().is_deprecated());
assert!(registry.get("rpc-passwd").unwrap().is_deprecated());
assert!(!registry.get("rpc-secret").unwrap().is_deprecated());
assert!(
!registry
.get("rpc-secret")
.unwrap()
.is_exposed_in_aria2_rpc()
);
}
#[cfg(feature = "bittorrent")]
#[test]
fn test_hidden_and_deprecated_option_sets_match_original_boundary() {
use std::collections::BTreeSet;
let registry = OptionRegistry::new();
let hidden = registry
.all()
.values()
.filter(|definition| definition.is_hidden())
.map(|definition| definition.name().to_owned())
.collect::<BTreeSet<_>>();
let deprecated = registry
.all()
.values()
.filter(|definition| definition.is_deprecated())
.map(|definition| definition.name().to_owned())
.collect::<BTreeSet<_>>();
assert_eq!(
hidden,
BTreeSet::from([
"bt-keep-alive-interval".to_string(),
"bt-request-timeout".to_string(),
"bt-timeout".to_string(),
"dht-listen-addr".to_string(),
"dns-timeout".to_string(),
"max-http-pipelining".to_string(),
"optimize-concurrent-downloads-coeffA".to_string(),
"optimize-concurrent-downloads-coeffB".to_string(),
"peer-connection-timeout".to_string(),
"select-least-used-host".to_string(),
"startup-idle-time".to_string(),
])
);
assert_eq!(
deprecated,
BTreeSet::from([
"enable-async-dns6".to_string(),
"rpc-passwd".to_string(),
"rpc-user".to_string(),
])
);
}
#[test]
fn test_option_def_parse_integer() {
let def = OptionDef {
name: "split".into(),
opt_type: OptionType::Integer,
min: Some(1),
max: Some(128),
..Default::default()
};
let v = def.parse_value("5").unwrap();
assert_eq!(v.as_i64().unwrap(), 5);
let err = def.parse_value("0");
assert!(err.is_err());
let err2 = def.parse_value("abc");
assert!(err2.is_err());
}
#[test]
fn test_option_def_parse_integer_range_preserves_wire_value() {
let def = OptionDef {
name: "listen-port".into(),
opt_type: OptionType::IntegerRange,
min: Some(1024),
max: Some(65535),
..Default::default()
};
assert_eq!(
def.parse_value("6881-6999,7001").unwrap().as_str(),
Some("6881-6999,7001")
);
assert!(def.parse_value("1023").is_err());
assert!(def.parse_value("70000").is_err());
assert!(def.parse_value("6881-").is_err());
assert!(def.parse_value("6881-6999-7000").is_err());
}
#[test]
fn test_option_def_parse_index_out_is_cumulative_wire_text() {
let def = OptionDef {
name: "index-out".into(),
opt_type: OptionType::IndexOut,
cumulative_delimiter: Some("\n"),
..Default::default()
};
assert_eq!(
def.parse_value("1=part.iso").unwrap().as_str(),
Some("1=part.iso")
);
assert!(def.parse_value("part.iso").is_err());
assert!(def.parse_value("1=").is_err());
}
#[test]
fn test_option_def_parse_piece_priority_matches_original_syntax() {
let def = OptionDef {
name: "bt-prioritize-piece".into(),
opt_type: OptionType::PiecePriority,
..Default::default()
};
assert_eq!(
def.parse_value("head=512K,tail").unwrap().as_str(),
Some("head=512K,tail")
);
assert!(def.parse_value("rarest").is_err());
assert!(def.parse_value("head=").is_err());
assert!(def.parse_value("tail=1G").is_err());
}
#[test]
fn test_parse_piece_priority_uses_original_default_size() {
assert_eq!(
super::parse_piece_priority("head,tail=2M").unwrap(),
vec![
super::PiecePriorityRule::Head { size: 1024 * 1024 },
super::PiecePriorityRule::Tail {
size: 2 * 1024 * 1024
},
]
);
assert!(super::parse_piece_priority("head,,tail").is_ok());
assert!(super::parse_piece_priority("head=0").is_ok());
}
#[test]
fn test_parse_index_out_preserves_order_and_paths() {
assert_eq!(
super::parse_index_out("1=first.iso\r\n2=dir/second.iso").unwrap(),
vec![
(1, "first.iso".to_string()),
(2, "dir/second.iso".to_string()),
]
);
assert!(super::parse_index_out("0=first.iso").is_ok());
assert!(super::parse_index_out("part.iso").is_err());
assert!(super::parse_index_out("1=").is_err());
}
#[test]
fn test_size_bounds_are_applied_by_the_definition() {
let def = OptionDef {
name: "piece-length".into(),
opt_type: OptionType::Size,
min: Some(1024 * 1024),
max: Some(1024 * 1024 * 1024),
..Default::default()
};
assert!(def.parse_value("1M").is_ok());
assert!(def.parse_value("512K").is_err());
assert!(def.parse_value("2G").is_err());
}
#[test]
fn test_option_def_parse_boolean() {
let def = OptionDef::new("verbose", OptionType::Boolean);
assert!(def.parse_value("true").unwrap().as_bool().unwrap());
assert!(!def.parse_value("false").unwrap().as_bool().unwrap());
assert!(def.parse_value("").unwrap().as_bool().unwrap());
assert!(def.parse_value("yes").is_err());
assert!(def.parse_value("1").is_err());
assert!(def.parse_value("no").is_err());
assert!(def.parse_value("TRUE").is_err());
assert!(def.parse_value("invalid").is_err());
}
#[test]
fn test_option_def_parse_list() {
let def = OptionDef::new("header", OptionType::List);
let v = def.parse_value("X-Custom:foo,X-Bar:baz").unwrap();
assert_eq!(v.as_list().unwrap().len(), 2);
}
#[test]
fn test_option_def_parse_enum_rejects_unknown_choice() {
let def = OptionDef {
name: "uri-selector".into(),
opt_type: OptionType::Enum,
allowed_values: &["inorder", "feedback", "adaptive"],
..Default::default()
};
assert_eq!(
def.parse_value("feedback").unwrap().as_str(),
Some("feedback")
);
assert!(def.parse_value("unknown").is_err());
}
#[test]
fn test_option_def_parse_explicit_empty_is_not_a_default_request() {
let def = OptionDef {
name: "dir".into(),
opt_type: OptionType::Path,
default_value: OptionValue::Str("/tmp".into()),
..Default::default()
};
let v = def.parse_value("").unwrap();
assert_eq!(v.as_str().unwrap(), "");
assert_eq!(def.parse_default_value().unwrap().as_str(), Some("/tmp"));
}
#[test]
fn test_rpc_empty_values_use_explicit_option_semantics() {
let registry = OptionRegistry::new();
assert_eq!(
registry
.parse_rpc_value("dir", &serde_json::json!(""))
.unwrap()
.as_str(),
Some("")
);
assert!(
registry
.parse_rpc_value("split", &serde_json::json!(""))
.is_err()
);
assert!(
registry
.parse_rpc_value("rpc-secret", &serde_json::json!(""))
.is_err()
);
assert!(!registry.get("rpc-secret").unwrap().allow_empty);
}
#[test]
fn test_option_value_parse_size_rejects_invalid_input() {
assert_eq!(
OptionValue::parse_size_str_checked("1.5M").unwrap(),
1_572_864
);
assert!(OptionValue::parse_size_str_checked("badvalue").is_err());
assert!(OptionValue::parse_size_str_checked("-1K").is_err());
}
#[test]
fn test_registry_creation() {
let reg = OptionRegistry::new();
assert!(reg.count() >= 60);
assert!(reg.get("split").is_some());
assert!(reg.get("nonexistent-option").is_none());
}
#[test]
#[should_panic(expected = "duplicate configuration option 'duplicate'")]
fn test_registry_rejects_duplicate_definitions() {
let mut reg = OptionRegistry::new();
reg.register(OptionDef::new("duplicate", OptionType::String));
reg.register(OptionDef::new("duplicate", OptionType::Boolean));
}
#[cfg(feature = "bittorrent")]
#[test]
fn test_bt_tracker_definition_matches_original_overwrite_semantics() {
let reg = OptionRegistry::new();
let def = reg
.get("bt-tracker")
.expect("bt-tracker must be registered");
assert_eq!(def.opt_type(), OptionType::List);
assert_eq!(def.cumulative_delimiter, None);
}
#[test]
fn test_registry_by_category() {
let reg = OptionRegistry::new();
let general = reg.by_category(OptionCategory::General);
let rpc = reg.by_category(OptionCategory::Rpc);
assert!(!general.is_empty());
#[cfg(feature = "bittorrent")]
{
let bt = reg.by_category(OptionCategory::BitTorrent);
assert!(!bt.is_empty());
}
assert!(!rpc.is_empty());
}
#[test]
fn test_rpc_cors_domain_is_unset_by_default() {
let reg = OptionRegistry::new();
let def = reg
.get("rpc-cors-domain")
.expect("rpc-cors-domain must be registered");
assert!(matches!(def.default_value(), OptionValue::None));
}
#[test]
fn test_registry_defaults_are_valid() {
let reg = OptionRegistry::new();
for def in reg.all().values() {
if !matches!(def.default_value(), OptionValue::None) {
let parsed = def.parse_value(&def.default_value().to_string());
assert!(
parsed.is_ok(),
"Default value for '{}' failed to re-parse: {:?}",
def.name(),
parsed.err()
);
}
}
}
#[test]
fn test_registry_identity_defaults_match_original_aria2() {
let registry = OptionRegistry::new();
assert_eq!(
registry
.get("user-agent")
.unwrap()
.default_value()
.to_string(),
aria2_protocol::identity::DEFAULT_USER_AGENT
);
#[cfg(feature = "bittorrent")]
{
assert_eq!(
registry
.get("peer-agent")
.unwrap()
.default_value()
.to_string(),
aria2_protocol::identity::DEFAULT_PEER_AGENT
);
assert_eq!(
registry
.get("peer-id-prefix")
.unwrap()
.default_value()
.to_string(),
aria2_protocol::identity::DEFAULT_PEER_ID_PREFIX
);
}
}
#[cfg(feature = "bittorrent")]
#[test]
fn test_piece_priority_has_no_synthetic_default() {
let registry = OptionRegistry::new();
assert!(matches!(
registry
.get("bt-prioritize-piece")
.expect("piece-priority option must be registered")
.default_value(),
OptionValue::None
));
}
#[cfg(feature = "bittorrent")]
#[test]
fn test_seed_time_has_no_default_but_preserves_explicit_zero() {
let registry = OptionRegistry::new();
let definition = registry
.get("seed-time")
.expect("seed-time option must be registered");
assert!(matches!(definition.default_value(), OptionValue::None));
assert_eq!(definition.parse_value("0").unwrap().as_f64(), Some(0.0));
}
#[test]
fn test_optimize_concurrent_download_coefficients_match_original_wire_names() {
let registry = OptionRegistry::new();
let coeff_a = registry
.get("optimize-concurrent-downloads-coeffA")
.expect("original coefficient A option must be registered");
let coeff_b = registry
.get("optimize-concurrent-downloads-coeffB")
.expect("original coefficient B option must be registered");
assert_eq!(coeff_a.default_value().as_f64(), Some(5.0));
assert_eq!(coeff_b.default_value().as_f64(), Some(25.0));
assert_eq!(coeff_a.parse_value("7.5").unwrap().as_f64(), Some(7.5));
assert_eq!(coeff_b.parse_value("30").unwrap().as_f64(), Some(30.0));
assert!(
registry
.get("optimize-concurrent-downloads-coeffa")
.is_none()
);
assert!(
registry
.get("optimize-concurrent-downloads-coeffb")
.is_none()
);
}
#[cfg(feature = "bittorrent")]
#[test]
fn test_registry_parses_rpc_wire_values_through_one_typed_seam() {
let reg = OptionRegistry::new();
assert_eq!(
reg.parse_rpc_value("split", &serde_json::json!(4))
.unwrap()
.as_i64(),
Some(4)
);
assert_eq!(
reg.parse_rpc_value("max-retries", &serde_json::json!(7))
.unwrap()
.as_i64(),
Some(7)
);
assert_eq!(
reg.parse_rpc_value("allow-overwrite", &serde_json::json!(true))
.unwrap()
.as_bool(),
Some(true)
);
assert_eq!(
reg.parse_rpc_value("uri-selector", &serde_json::json!("adaptive"))
.unwrap()
.as_str(),
Some("adaptive")
);
assert!(
reg.parse_rpc_value("uri-selector", &serde_json::json!("unsupported"))
.is_err()
);
assert!(
reg.parse_rpc_value("split", &serde_json::json!({"value": 4}))
.is_err()
);
assert!(
reg.parse_rpc_value("split", &serde_json::json!([4]))
.is_err()
);
assert!(
reg.parse_rpc_value("header", &serde_json::json!(["X-Test: 1"]))
.is_ok()
);
assert_eq!(
reg.parse_rpc_value("listen-port", &serde_json::json!("6881-6999"))
.unwrap()
.as_str(),
Some("6881-6999")
);
assert_eq!(
reg.parse_rpc_value("bt-prioritize-piece", &serde_json::json!("head=2M,tail"))
.unwrap()
.as_str(),
Some("head=2M,tail")
);
assert!(
reg.parse_rpc_value("bt-prioritize-piece", &serde_json::json!("rarest"))
.is_err()
);
assert!(
reg.parse_rpc_value("select-file", &serde_json::json!("0"))
.is_err()
);
assert!(
reg.parse_rpc_value("index-out", &serde_json::json!("1=file.iso"))
.is_ok()
);
}
#[test]
fn test_default_registry() {
let reg = OptionRegistry::default();
assert!(reg.count() > 0);
}
#[test]
fn test_range_validator_in_range() {
let validator = RangeValidator::<i64>::new(1, 16);
assert!(validator.validate("split", &Value::from(1)).is_ok());
assert!(validator.validate("split", &Value::from(8)).is_ok());
assert!(validator.validate("split", &Value::from(16)).is_ok());
let float_validator = RangeValidator::<f64>::new(0.0, 1.0);
assert!(float_validator.validate("ratio", &Value::from(0.5)).is_ok());
let u64_validator = RangeValidator::<u64>::new(1024, 1024 * 1024);
assert!(
u64_validator
.validate("size", &Value::from(4096u64))
.is_ok()
);
}
#[test]
fn test_range_validator_out_of_range() {
let validator = RangeValidator::<i64>::new(1, 16);
let result = validator.validate("split", &Value::from(0));
assert!(result.is_err());
match result.unwrap_err() {
OptionError::OutOfRange { value, min, max } => {
assert_eq!(value, "0");
assert_eq!(min, "1");
assert_eq!(max, "16");
}
other => panic!("Expected OutOfRange error, got {:?}", other),
}
}
#[test]
fn test_choice_validator_enum() {
let validator = ChoiceValidator::new(vec![
"debug".to_string(),
"info".to_string(),
"warn".to_string(),
"error".to_string(),
]);
assert!(
validator
.validate("log-level", &Value::String("debug".into()))
.is_ok()
);
assert!(
validator
.validate("log-level", &Value::String("verbose".into()))
.is_err()
);
}
#[test]
fn test_url_validator_malformed() {
let validator = UrlValidator::new();
assert!(
validator
.validate(
"tracker",
&Value::String("http://example.com:6969/announce".into())
)
.is_ok()
);
assert!(
validator
.validate("url", &Value::String("not-a-url".into()))
.is_err()
);
}
#[test]
fn test_regex_validator_pattern_match() {
let validator = RegexValidator::new(r"^[a-zA-Z0-9.-]+:\d+$");
assert!(
validator
.validate("proxy", &Value::String("proxy.example.com:8080".into()))
.is_ok()
);
assert!(
validator
.validate("proxy", &Value::String("not-valid".into()))
.is_err()
);
}
#[test]
fn test_dependency_checker() {
let mut checker = DependencyChecker::new();
checker.add_mutual_exclusion("ftp-pasv".to_string(), "ftp-port".to_string());
checker.add_requirement("bt-enable-lpd".to_string(), "enable-dht".to_string());
let mut opts = HashMap::new();
opts.insert("ftp-pasv".to_string(), Value::Bool(true));
opts.insert("ftp-port".to_string(), Value::from(8021));
let errors = checker.check(&opts);
assert_eq!(errors.len(), 1);
}
#[test]
fn test_option_definition_validation() {
let def = OptionDefinition {
name: "max-connections",
description: "Maximum connections per server",
default_value: Value::from(16),
validator: Some(Box::new(RangeValidator::<i64>::new(1, 32))),
};
assert!(def.validate(&Value::from(8)).is_ok());
assert!(def.validate(&Value::from(0)).is_err());
}
#[test]
fn test_option_error_display() {
let err = OptionError::TypeMismatch {
expected: "integer".to_string(),
got: "string".to_string(),
};
let msg = format!("{}", err);
assert!(msg.contains("type mismatch"));
}