aria2-protocol 0.3.10

Multi-protocol networking stack for aria2-rust: HTTP/HTTPS client, FTP/SFTP, full BitTorrent (DHT/PEX/MSE), and Metalink V3/V4 parser
Documentation
use super::super::routing_table::RoutingTable;
use super::*;
use std::path::PathBuf;

#[test]
fn test_snapshot_freshness_rejects_old_timestamps() {
    assert!(DhtPersistence::is_fresh(
        u64::MAX,
        std::time::Duration::from_secs(60)
    ));
    assert!(!DhtPersistence::is_fresh(
        0,
        std::time::Duration::from_secs(60)
    ));
}

#[test]
fn test_serialize_header_magic_and_version() {
    let id = [0x42u8; 20];
    let data = DhtPersistence::serialize(&id, &[]);
    assert_eq!(data[0], 0xA1);
    assert_eq!(data[1], 0xA2);
    assert_eq!(data[2], 0x02);
    assert_eq!(data[7], 0x03);
}

#[test]
fn test_serialize_local_node_id() {
    let id = [0xABu8; 20];
    let data = DhtPersistence::serialize(&id, &[]);
    let stored_id: [u8; 20] = data[24..44].try_into().unwrap();
    assert_eq!(stored_id, id);
}

#[test]
fn test_serialize_nodes_ipv4() {
    let id = [0u8; 20];
    let addr: std::net::SocketAddr = "192.168.1.100:6881".parse().unwrap();
    let node = DhtNode::new(id, addr);
    let data = DhtPersistence::serialize(&id, &[node]);

    assert_eq!(data[56], 6, "IPv4 compact length should be 6");
    let ip_start = 64;
    assert_eq!(data[ip_start], 192);
    assert_eq!(data[ip_start + 1], 168);
    assert_eq!(data[ip_start + 2], 1);
    assert_eq!(data[ip_start + 3], 100);
    let port = u16::from_be_bytes([data[ip_start + 4], data[ip_start + 5]]);
    assert_eq!(port, 6881);
    assert_eq!(data.len(), 56 + NODE_ENTRY_SIZE);
}

#[test]
fn test_serialize_nodes_ipv6() {
    let id = [0u8; 20];
    let addr: std::net::SocketAddr = "[::1]:6882".parse().unwrap();
    let node = DhtNode::new(id, addr);
    let data = DhtPersistence::serialize(&id, &[node]);

    assert_eq!(data[56], 18, "IPv6 compact length should be 18");
}

#[test]
fn test_serialize_empty_routing_table() {
    let id = [0xFFu8; 20];
    let data = DhtPersistence::serialize(&id, &[]);

    let num_nodes = u32::from_be_bytes([data[44], data[45], data[46], data[47]]);
    assert_eq!(num_nodes, 0);
    assert_eq!(
        data.len(),
        56,
        "empty table should be exactly 56 bytes (header+ts+localnode+count)"
    );
}

#[test]
fn test_deserialize_v3_format() {
    let id = [0x11u8; 20];
    let addr: std::net::SocketAddr = "10.0.0.5:6881".parse().unwrap();
    let node = DhtNode::new(id, addr);
    let serialized = DhtPersistence::serialize(&id, &[node]);

    let result = DhtPersistence::deserialize(&serialized).unwrap();
    assert_eq!(result.self_id, id);
    assert_eq!(result.nodes.len(), 1);
    assert_eq!(result.nodes[0].id, id);
    assert_eq!(result.nodes[0].addr, addr);
}

#[test]
fn test_deserialize_aria2_compatible_v2_format() {
    let self_id = [0x31u8; 20];
    let node_id = [0x71u8; 20];
    let addr: std::net::SocketAddr = "203.0.113.17:6881".parse().unwrap();
    let node = DhtNode::new(node_id, addr);
    let mut serialized = DhtPersistence::serialize(&self_id, &[node]);

    serialized[7] = 0x02;
    serialized[8..12].copy_from_slice(&1_700_000_000u32.to_be_bytes());
    serialized[12..16].fill(0);

    let restored = DhtPersistence::deserialize(&serialized)
        .expect("aria2 v2 DHT routing-table snapshots should remain readable");
    assert_eq!(restored.self_id, self_id);
    assert_eq!(restored.saved_at_secs, 1_700_000_000);
    assert_eq!(restored.nodes.len(), 1);
    assert_eq!(restored.nodes[0].id, node_id);
    assert_eq!(restored.nodes[0].addr, addr);
}

#[test]
fn test_repeated_file_save_replaces_existing_snapshot() {
    let dir = tempfile::tempdir_in(std::env::current_dir().unwrap()).unwrap();
    let path = dir.path().join("dht.dat");
    let first = DhtNode::new([0x01; 20], "127.0.0.1:6881".parse().unwrap());
    let second = DhtNode::new([0x02; 20], "127.0.0.1:6882".parse().unwrap());
    DhtPersistence::save_to_file_sync(&path, &[0xAA; 20], &[first]).unwrap();
    DhtPersistence::save_to_file_sync(&path, &[0xBB; 20], std::slice::from_ref(&second)).unwrap();

    let restored = DhtPersistence::load_from_file_sync(&path).unwrap();
    assert_eq!(restored.self_id, [0xBB; 20]);
    assert_eq!(restored.nodes.len(), 1);
    assert_eq!(restored.nodes[0].id, second.id);
    assert_eq!(restored.nodes[0].addr, second.addr);
}

#[test]
fn test_roundtrip_serialize_deserialize() {
    let self_id = [0xDEu8; 20];
    let addrs: Vec<std::net::SocketAddr> = vec![
        "1.2.3.4:6881".parse().unwrap(),
        "[2001:db8::1]:6882".parse().unwrap(),
        "10.0.0.1:6883".parse().unwrap(),
    ];
    let nodes: Vec<DhtNode> = addrs
        .iter()
        .enumerate()
        .map(|(i, a)| DhtNode::new([i as u8; 20], *a))
        .collect();

    let serialized = DhtPersistence::serialize(&self_id, &nodes);
    let deserialized = DhtPersistence::deserialize(&serialized).unwrap();

    assert_eq!(deserialized.self_id, self_id);
    assert_eq!(deserialized.nodes.len(), 3);
    for (i, node) in deserialized.nodes.iter().enumerate().take(3) {
        assert_eq!(node.addr, addrs[i]);
    }
}

#[test]
fn test_reject_bad_header() {
    let bad_data = vec![0x00u8; 16];
    let result = DhtPersistence::deserialize(&bad_data);
    assert!(result.is_err(), "bad magic should fail");
}

#[test]
fn test_collect_good_nodes_only() {
    let mut rt = RoutingTable::new([0x80u8; 20]);

    let good_addr = "127.0.0.1:6881".parse().unwrap();
    let good_node = DhtNode::new([1u8; 20], good_addr);

    let bad_addr = "127.0.0.1:6882".parse().unwrap();
    let mut bad_node = DhtNode::new([2u8; 20], bad_addr);
    for _ in 0..5 {
        bad_node.record_failure();
    }

    rt.insert(good_node);
    rt.insert(bad_node);

    let collected = rt.collect_good_nodes();
    assert_eq!(collected.len(), 1);
    assert_eq!(collected[0].addr, good_addr);
}

#[test]
fn test_save_load_file_roundtrip() {
    let dir = tempfile::tempdir_in(std::env::current_dir().unwrap()).unwrap();
    let path = dir.path().join("dht.dat");

    let self_id = [0x99u8; 20];
    let addr = "172.16.0.1:9999".parse().unwrap();
    let node = DhtNode::new([0xAAu8; 20], addr);

    let rt = tokio::runtime::Runtime::new().unwrap();
    rt.block_on(async {
        DhtPersistence::save_to_file(&path, &self_id, &[node])
            .await
            .unwrap();

        let loaded = DhtPersistence::load_from_file(&path).await.unwrap();
        assert_eq!(loaded.self_id, self_id);
        assert_eq!(loaded.nodes.len(), 1);
        assert_eq!(loaded.nodes[0].id, [0xAAu8; 20]);
        assert_eq!(loaded.nodes[0].addr, addr);
    });
}

#[test]
fn test_multiple_nodes_roundtrip() {
    let self_id = [0x12u8; 20];
    let mut nodes = Vec::new();
    for i in 0u8..20 {
        let octets = [192, 0, 1, i + 1];
        let addr = std::net::SocketAddr::V4(std::net::SocketAddrV4::new(
            std::net::Ipv4Addr::new(octets[0], octets[1], octets[2], octets[3]),
            6881 + i as u16,
        ));
        nodes.push(DhtNode::new([i; 20], addr));
    }

    let serialized = DhtPersistence::serialize(&self_id, &nodes);
    let deserialized = DhtPersistence::deserialize(&serialized).unwrap();
    assert_eq!(deserialized.nodes.len(), 20);
}

#[test]
fn test_truncated_data_error() {
    let short_data = vec![0xA1, 0xA2];
    let result = DhtPersistence::deserialize(&short_data);
    assert!(result.is_err());
}

#[test]
fn test_truncated_node_record_is_rejected() {
    let node = DhtNode::new([0x11; 20], "127.0.0.1:6881".parse().unwrap());
    let mut data = DhtPersistence::serialize(&[0x22; 20], &[node]);
    data.truncate(data.len() - 1);

    assert!(DhtPersistence::deserialize(&data).is_err());
}

#[test]
fn test_invalid_compact_peer_length_is_rejected() {
    let node = DhtNode::new([0x11; 20], "127.0.0.1:6881".parse().unwrap());
    let mut data = DhtPersistence::serialize(&[0x22; 20], &[node]);
    data[56] = 5;

    assert!(DhtPersistence::deserialize(&data).is_err());
}

#[test]
fn test_socket_addr_to_compact_ipv4() {
    let addr: std::net::SocketAddr = "8.8.8.8:53".parse().unwrap();
    let compact = socket_addr_to_compact(&addr);
    assert_eq!(compact.len(), 6);
    assert_eq!(compact[0], 8);
    assert_eq!(compact[1], 8);
    assert_eq!(compact[2], 8);
    assert_eq!(compact[3], 8);
    let port = u16::from_be_bytes([compact[4], compact[5]]);
    assert_eq!(port, 53);
}

#[test]
fn test_compact_to_socket_addr_ipv4() {
    let compact: Vec<u8> = vec![127, 0, 0, 1, 0x1A, 0x0B];
    let addr = compact_to_socket_addr(&compact).unwrap();
    assert_eq!(
        addr,
        "127.0.0.1:6667".parse::<std::net::SocketAddr>().unwrap()
    );
}

#[test]
fn test_load_nonexistent_file_error() {
    let path = PathBuf::from("/nonexistent/path/dht.dat");
    let rt = tokio::runtime::Runtime::new().unwrap();
    let result = rt.block_on(async { DhtPersistence::load_from_file(&path).await });
    assert!(result.is_err());
}