aria2-core 0.3.13

aria2-rust core download engine: multi-protocol segmented downloads, rate limiting, configuration, session persistence, and BitTorrent seeding
Documentation
#[test]
fn manager_lists_and_finds_live_handles_without_exposing_groups() {
    let group_man = Arc::new(RequestGroupMan::new());
    let (command_sender, _command_receiver) = super::super::engine_command::channel();
    let manager = manager(Arc::clone(&group_man), command_sender);
    let handle = manager
        .add_uri(
            vec!["http://example.test/file".to_string()],
            DownloadOptions::default(),
        )
        .expect("download submission");

    let handles = manager.handles();
    assert_eq!(handles.len(), 1);
    assert_eq!(handles[0].gid(), handle.gid());
    assert!(manager.find(handle.gid()).is_some());
    assert!(manager.find(GroupId::new(0xdead_beef)).is_none());
}

#[test]
fn manager_exposes_batch_lifecycle_commands() {
    let group_man = Arc::new(RequestGroupMan::new());
    let (command_sender, mut command_receiver) = super::super::engine_command::channel();
    let manager = manager(Arc::clone(&group_man), command_sender);

    manager
        .pause_all()
        .expect("pause-all command should be accepted");
    assert!(matches!(
        command_receiver.try_recv(),
        Ok(EngineCommand::PauseAll)
    ));

    manager
        .force_pause_all()
        .expect("force-pause-all command should be accepted");
    assert!(matches!(
        command_receiver.try_recv(),
        Ok(EngineCommand::ForcePauseAll)
    ));

    manager
        .resume_all()
        .expect("resume-all command should be accepted");
    assert!(matches!(
        command_receiver.try_recv(),
        Ok(EngineCommand::UnpauseAll)
    ));

    manager
        .set_max_concurrent(3)
        .expect("max-concurrent command should be accepted");
    assert!(matches!(
        command_receiver.try_recv(),
        Ok(EngineCommand::SetMaxConcurrent { max: 3 })
    ));

    manager
        .set_global_rate_limit(Some(1024), None)
        .expect("global rate-limit command should be accepted");
    assert!(matches!(
        command_receiver.try_recv(),
        Ok(EngineCommand::SetGlobalRateLimit {
            download_limit: Some(1024),
            upload_limit: None,
        })
    ));
}

#[test]
fn manager_exposes_runtime_queries_and_stopped_results() {
    let group_man = Arc::new(RequestGroupMan::new());
    let (command_sender, _command_receiver) = super::super::engine_command::channel();
    let manager = manager(Arc::clone(&group_man), command_sender);

    assert_eq!(manager.max_concurrent(), 5);
    assert_eq!(manager.global_download_limit(), None);
    assert_eq!(manager.global_upload_limit(), None);
    assert_eq!(manager.stopped_results_len(), 0);

    let handle = manager
        .add_uri(
            vec!["https://example.test/file".to_string()],
            DownloadOptions::default(),
        )
        .expect("download submission");
    group_man
        .remove_group(handle.gid())
        .expect("reserved download should be removable");

    assert_eq!(manager.stopped_results_len(), 1);
    assert_eq!(manager.stopped_results(0, 1)[0].gid, handle.gid());
    assert_eq!(manager.clear_completed().expect("clear should succeed"), 1);
    assert_eq!(manager.stopped_results_len(), 0);
}

#[test]
fn handle_exposes_file_snapshot_without_rpc_polling() {
    let group_man = Arc::new(RequestGroupMan::new());
    let (command_sender, _command_receiver) = super::super::engine_command::channel();
    let manager = manager(Arc::clone(&group_man), command_sender);
    let handle = manager
        .add_uri(
            vec!["https://example.test/file.zip".to_string()],
            DownloadOptions::default(),
        )
        .expect("download submission");

    let files = handle.get_files().expect("live group snapshot");
    assert_eq!(files.len(), 1);
    assert_eq!(files[0].path, "file.zip");
    let uris = handle.get_uris().expect("URI snapshot");
    assert_eq!(uris.len(), 1);
    assert_eq!(uris[0].uri, "https://example.test/file.zip");
}

#[tokio::test]
async fn handle_changes_uris_and_wakes_snapshot_observers() {
    let group_man = Arc::new(RequestGroupMan::new());
    let (command_sender, _command_receiver) = super::super::engine_command::channel();
    let manager = manager(Arc::clone(&group_man), command_sender);
    let handle = manager
        .add_uri(
            vec!["https://example.test/first".to_string()],
            DownloadOptions::default(),
        )
        .expect("download submission");
    let signal = group_man.activity_signal();
    let mut observed = signal.generation();
    let add_uris = vec!["https://example.test/second".to_string()];

    assert_eq!(
        handle
            .change_uris(1, &[], &add_uris, Some(0))
            .expect("URI change should succeed"),
        (0, 1)
    );
    tokio::time::timeout(
        Duration::from_secs(1),
        signal.wait_for_change(&mut observed),
    )
    .await
    .expect("URI changes must wake snapshot observers");

    let files = handle.get_files().expect("live group snapshot");
    assert_eq!(files[0].uris[0].uri, add_uris[0]);
}

#[test]
fn handle_applies_runtime_options_through_manager_policy() {
    let group_man = Arc::new(RequestGroupMan::new());
    let (command_sender, _command_receiver) = super::super::engine_command::channel();
    let manager = manager(Arc::clone(&group_man), command_sender);
    let handle = manager
        .add_uri(
            vec!["https://example.test/file".to_string()],
            DownloadOptions::default(),
        )
        .expect("download submission");
    let mut changes = HashMap::new();
    changes.insert("dir".to_string(), serde_json::json!("reserved-dir"));

    handle
        .change_options(changes)
        .expect("runtime option change should succeed");

    let group = group_man.find_group(handle.gid()).expect("group exists");
    let runtime_options = group.recover().runtime_options();
    assert_eq!(
        runtime_options.get("dir"),
        Some(&serde_json::json!("reserved-dir"))
    );
    assert_eq!(
        handle
            .runtime_options()
            .expect("live runtime options")
            .get("dir"),
        Some(&serde_json::json!("reserved-dir"))
    );
    assert!(
        handle
            .pending_options()
            .expect("live pending options")
            .is_empty()
    );
}

#[test]
fn handle_changes_reserved_queue_position() {
    let group_man = Arc::new(RequestGroupMan::new());
    let (command_sender, _command_receiver) = super::super::engine_command::channel();
    let manager = manager(Arc::clone(&group_man), command_sender);
    let first = manager
        .add_uri(
            vec!["https://example.test/first".to_string()],
            DownloadOptions::default(),
        )
        .expect("first download submission");
    let second = manager
        .add_uri(
            vec!["https://example.test/second".to_string()],
            DownloadOptions::default(),
        )
        .expect("second download submission");

    assert_eq!(
        second
            .change_position(0, PositionMode::SetFromStart)
            .expect("reserved position change"),
        0
    );
    assert!(matches!(
        first.change_position(-1, PositionMode::SetFromStart),
        Err(DownloadManagerError::State(Aria2Error::InvalidArgument(_)))
    ));
}