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::*;

#[tokio::test]
async fn test_metadata_provenance_roundtrip_via_json_persistence() {
    let session_dir = create_test_session_dir();
    let persistence = SessionPersistence::new(&session_dir);
    let group = Arc::new(std::sync::RwLock::new(RequestGroup::new(
        GroupId::new(0xabc),
        vec!["bt://payload".to_string()],
        DownloadOptions::default(),
    )));
    group.recover().set_metadata_info(
        MetadataInfo::new(GroupId::new(0xabc), "https://example.test/meta.torrent")
            .with_metadata_path(session_dir.join("payload.torrent").to_string_lossy()),
    );

    assert_eq!(
        persistence.save_state(&[Arc::clone(&group)]).await.unwrap(),
        1
    );
    let mut restored = Vec::new();
    assert_eq!(
        SessionPersistence::new(&session_dir)
            .load_state(&mut restored)
            .await
            .unwrap(),
        1
    );
    let restored_info = restored[0].recover().metadata_info();
    assert!(restored_info.is_some());
    assert_eq!(
        restored_info.as_ref().and_then(|info| info.metadata_path()),
        Some(
            session_dir
                .join("payload.torrent")
                .to_string_lossy()
                .as_ref()
        )
    );

    let _ = fs::remove_dir_all(&session_dir);
}

#[tokio::test]
async fn test_follow_mode_variants_roundtrip_via_persistence() {
    let session_dir = create_test_session_dir();
    let persistence = SessionPersistence::new(&session_dir);
    let modes = [
        (FollowMode::Follow, FollowMode::Disabled),
        (FollowMode::Disabled, FollowMode::Follow),
        (FollowMode::Memory, FollowMode::Memory),
    ];
    let groups = modes
        .iter()
        .enumerate()
        .map(|(index, &(follow_torrent, follow_metalink))| {
            Arc::new(std::sync::RwLock::new(RequestGroup::new(
                GroupId::new(0x400 + index as u64),
                vec![format!("https://example.test/metadata-{index}.bin")],
                DownloadOptions {
                    follow_torrent: Some(follow_torrent),
                    follow_metalink: Some(follow_metalink),
                    ..Default::default()
                },
            )))
        })
        .collect::<Vec<_>>();

    assert_eq!(persistence.save_state(&groups).await.unwrap(), modes.len());

    let mut restored = Vec::new();
    assert_eq!(
        SessionPersistence::new(&session_dir)
            .load_state(&mut restored)
            .await
            .unwrap(),
        modes.len()
    );

    for (index, &(follow_torrent, follow_metalink)) in modes.iter().enumerate() {
        let group = restored
            .iter()
            .find(|group| group.recover().gid() == GroupId::new(0x400 + index as u64))
            .expect("follow-mode group should be restored");
        let options = group.recover().options().clone();
        assert_eq!(options.follow_torrent, Some(follow_torrent));
        assert_eq!(options.follow_metalink, Some(follow_metalink));
    }

    let _ = fs::remove_dir_all(&session_dir);
}

#[cfg(all(feature = "metalink", feature = "bittorrent"))]
#[tokio::test]
async fn test_metalink_torrent_graph_is_rebuilt_after_session_load() {
    let session_dir = create_test_session_dir();
    let persistence = SessionPersistence::new(&session_dir);
    let metadata_path = session_dir.join("payload.torrent");
    let payload = Arc::new(std::sync::RwLock::new(RequestGroup::new(
        GroupId::new(0x222),
        vec!["bt://metadata".to_string()],
        DownloadOptions {
            dir: Some(session_dir.to_string_lossy().into_owned()),
            out: Some("payload.bin".to_string()),
            ..Default::default()
        },
    )));
    payload.recover().set_metadata_info(
        MetadataInfo::new(GroupId::new(0x111), "https://example.test/payload.torrent")
            .with_metadata_path(metadata_path.to_string_lossy()),
    );

    assert_eq!(
        persistence
            .save_state(&[Arc::clone(&payload)])
            .await
            .unwrap(),
        1
    );

    let mut restored = Vec::new();
    assert_eq!(
        SessionPersistence::new(&session_dir)
            .load_state(&mut restored)
            .await
            .unwrap(),
        1
    );
    assert_eq!(restored.len(), 2);

    let metadata = restored
        .iter()
        .find(|group| group.recover().gid() == GroupId::new(0x111))
        .expect("metadata prerequisite should be restored");
    assert_eq!(
        metadata
            .recover()
            .uris()
            .iter()
            .map(|uri| uri.as_ref())
            .collect::<Vec<_>>(),
        ["https://example.test/payload.torrent"]
    );
    assert_eq!(
        metadata.recover().belongs_to_gid(),
        Some(GroupId::new(0x222))
    );

    let restored_payload = restored
        .iter()
        .find(|group| group.recover().gid() == GroupId::new(0x222))
        .expect("payload should be restored");
    assert!(!restored_payload.recover().is_dependency_resolved());
    assert_eq!(
        restored_payload.recover().metadata_info().unwrap().gid(),
        Some(GroupId::new(0x111))
    );

    let _ = fs::remove_dir_all(&session_dir);
}

#[cfg(all(feature = "metalink", feature = "bittorrent"))]
#[tokio::test]
async fn test_json_session_roundtrip_preserves_metalink_graph_descriptor() {
    let session_dir = create_test_session_dir();
    let options = DownloadOptions {
        dir: Some(session_dir.to_string_lossy().into_owned()),
        ..Default::default()
    };
    let graph = crate::engine::metalink::request_graph::MetalinkRequestGraph::new_memory_with_fallback_and_mappings(
        "https://example.test/payload.torrent",
        "payload.bin",
        &options,
        GroupId::new(0x501),
        GroupId::new(0x502),
        vec!["https://mirror.example.test/payload.bin".to_string()],
        vec![crate::request::request_group::BtFileMapping {
            original_name: "payload.bin".to_string(),
            path: session_dir.join("payload.bin").to_string_lossy().into_owned(),
            uris: vec!["https://mirror.example.test/payload.bin".to_string()],
            max_connection_per_server: 3,
            unique_protocol: true,
        }],
    )
    .unwrap();
    let torrent_data = {
        let mut data =
            b"d8:announce28:http://tracker.test/announce4:infod6:lengthi0e4:name4:test12:piece lengthi16384e6:pieces20:".to_vec();
        data.extend_from_slice(&[
            0xda, 0x39, 0xa3, 0xee, 0x5e, 0x6b, 0x4b, 0x0d, 0x32, 0x55, 0xbf, 0xef, 0x95, 0x60,
            0x18, 0x90, 0xaf, 0xd8, 0x07, 0x09,
        ]);
        data.extend_from_slice(b"ee");
        data
    };
    let torrent_len = torrent_data.len();
    graph
        .payload
        .recover()
        .set_bt_metadata_data(torrent_data.clone());

    let persistence = SessionPersistence::new(&session_dir);
    assert_eq!(
        persistence
            .save_state(&[Arc::clone(&graph.payload)])
            .await
            .unwrap(),
        1
    );

    let mut restored = Vec::new();
    assert_eq!(
        SessionPersistence::new(&session_dir)
            .load_state(&mut restored)
            .await
            .unwrap(),
        1
    );
    assert_eq!(restored.len(), 2);

    let payload = restored
        .iter()
        .find(|group| group.recover().gid() == GroupId::new(0x502))
        .expect("payload should be restored");
    let descriptor = payload
        .recover()
        .bt_dependency_descriptor()
        .expect("BT dependency descriptor should be rebuilt");
    assert!(descriptor.0);
    assert_eq!(
        descriptor.1,
        vec!["https://mirror.example.test/payload.bin"]
    );
    assert_eq!(descriptor.2.len(), 1);
    assert_eq!(descriptor.2[0].max_connection_per_server, 3);
    assert!(descriptor.2[0].unique_protocol);
    assert_eq!(payload.recover().bt_metadata_data(), Some(torrent_data));

    let metadata = restored
        .iter()
        .find(|group| group.recover().gid() == GroupId::new(0x501))
        .expect("metadata source should be restored");
    assert!(metadata.recover().is_in_memory_download());
    assert_eq!(
        metadata.recover().in_memory_data().map(|data| data.len()),
        Some(torrent_len)
    );

    let _ = fs::remove_dir_all(&session_dir);
}