torrent 0.1.2

High-level async BitTorrent library — session management, HTTP/UDP tracker communication, DHT networking, peer connections, and file storage. Built on torrent-core with tokio.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! Integration tests for the Session API.

use bytes::Bytes;
use torrent::bencode::{Bencode, encode};
use torrent::error::{Error, ErrorKind};
use torrent::session::{Session, SessionConfig, TorrentState};

/// Helper: build synthetic single-file .torrent data.
fn make_single_file_torrent() -> Vec<u8> {
    let info_dict = Bencode::Dict(vec![
        (Bytes::from("name"), Bencode::Bytes(Bytes::from("test.txt"))),
        (Bytes::from("piece length"), Bencode::Integer(16384)),
        (Bytes::from("length"), Bencode::Integer(1024)),
        (
            Bytes::from("pieces"),
            Bencode::Bytes(Bytes::from(vec![0u8; 20])),
        ),
    ]);
    let root = Bencode::Dict(vec![
        (
            Bytes::from("announce"),
            Bencode::Bytes(Bytes::from("http://tracker.example.com/announce")),
        ),
        (Bytes::from("info"), info_dict),
    ]);
    encode(&root)
}

#[tokio::test]
async fn session_config_defaults() {
    let cfg = SessionConfig::default();
    assert_eq!(cfg.listen_port, 6881);
    assert_eq!(cfg.max_connections, 50);
    assert_eq!(cfg.max_uploads, 8);
    assert!(cfg.enable_dht);
}

#[tokio::test]
async fn session_new_with_temp_dir() -> Result<(), Error> {
    let tmp = tempfile::tempdir().unwrap();
    let config = SessionConfig {
        download_dir: tmp.path().to_path_buf(),
        enable_dht: false,
        ..Default::default()
    };
    let session = Session::new(config).await?;
    assert!(session.active_torrents().await.is_empty());
    Ok(())
}

#[tokio::test]
async fn add_torrent_bytes_and_query_status() -> Result<(), Error> {
    let tmp = tempfile::tempdir().unwrap();
    let config = SessionConfig {
        download_dir: tmp.path().to_path_buf(),
        enable_dht: false,
        ..Default::default()
    };
    let session = Session::new(config).await?;

    let data = make_single_file_torrent();
    let info_hash = session.add_torrent_bytes(&data).await?;

    // Verify the torrent appears in active list
    let active = session.active_torrents().await;
    assert_eq!(active.len(), 1);
    assert_eq!(active[0], info_hash);

    // Query its status
    let status = session.torrent_status(&info_hash).await?;
    assert_eq!(status.info_hash, info_hash);
    assert_eq!(status.name, "test.txt");
    assert_eq!(status.state, TorrentState::Queued);
    assert_eq!(status.progress, 0.0);

    Ok(())
}

#[tokio::test]
async fn remove_torrent() -> Result<(), Error> {
    let tmp = tempfile::tempdir().unwrap();
    let config = SessionConfig {
        download_dir: tmp.path().to_path_buf(),
        enable_dht: false,
        ..Default::default()
    };
    let session = Session::new(config).await?;

    let data = make_single_file_torrent();
    let info_hash = session.add_torrent_bytes(&data).await?;
    assert_eq!(session.active_torrents().await.len(), 1);

    session.remove_torrent(&info_hash).await?;
    assert!(session.active_torrents().await.is_empty());

    // Querying a removed torrent should fail
    let err = session.torrent_status(&info_hash).await.unwrap_err();
    assert_eq!(err.kind(), ErrorKind::InvalidInput);

    Ok(())
}

#[tokio::test]
async fn add_and_query_multiple_times() -> Result<(), Error> {
    let tmp = tempfile::tempdir().unwrap();
    let config = SessionConfig {
        download_dir: tmp.path().to_path_buf(),
        enable_dht: false,
        ..Default::default()
    };
    let session = Session::new(config).await?;

    let data = make_single_file_torrent();
    let info_hash = session.add_torrent_bytes(&data).await?;

    // Query status multiple times — should be consistent
    for _ in 0..3 {
        let status = session.torrent_status(&info_hash).await?;
        assert_eq!(status.info_hash, info_hash);
        assert_eq!(status.state, TorrentState::Queued);
    }

    Ok(())
}