aria2-core 0.3.13

aria2-rust core download engine: multi-protocol segmented downloads, rate limiting, configuration, session persistence, and BitTorrent seeding
Documentation
use super::*;

// ==================== Type Tests ====================

#[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()
    );
}

#[test]
fn max_http_pipelining_is_explicitly_rejected_without_runtime_support() {
    let registry = OptionRegistry::new();

    let error = registry
        .parse_rpc_value("max-http-pipelining", &serde_json::json!(2))
        .expect_err("unsupported HTTP pipeline limits must not be silently stored");

    assert!(
        error.contains("max-http-pipelining"),
        "unexpected error: {error}"
    );
}

#[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);
    assert_eq!(
        def.parse_value("").unwrap().as_list().unwrap(),
        &vec![String::new()]
    );
}

#[test]
fn test_empty_tracker_source_parses_as_empty_list() {
    let def = OptionDef::new("bt-tracker-source", OptionType::List);
    assert!(def.parse_value("").unwrap().as_list().unwrap().is_empty());
}

#[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());
}