caesura 0.30.2

An all-in-one command line tool to transcode FLAC audio files and upload to gazelle based indexers/trackers
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

use crate::testing_prelude::*;

#[tokio::test]
async fn read_source_torrent() {
    // Arrange
    let album = AlbumProvider::get(SampleFormat::default()).await;
    let path = SAMPLE_SOURCES_DIR.join(album.torrent_filename());

    // Act
    let torrent = TorrentReader::execute(&path)
        .await
        .expect("should read torrent");

    // Assert
    assert_eq!(torrent.name, album.dir_name());
    assert!(torrent.is_private());
}

#[tokio::test]
async fn read_source_torrent_has_source() {
    // Arrange
    let album = AlbumProvider::get(SampleFormat::default()).await;
    let path = SAMPLE_SOURCES_DIR.join(album.torrent_filename());

    // Act
    let torrent = TorrentReader::execute(&path)
        .await
        .expect("should read torrent");

    // Assert
    assert_eq!(torrent.source(), Some("RED"));
}

#[tokio::test]
async fn read_source_torrent_has_created_by() {
    // Arrange
    let album = AlbumProvider::get(SampleFormat::default()).await;
    let path = SAMPLE_SOURCES_DIR.join(album.torrent_filename());

    // Act
    let torrent = TorrentReader::execute(&path)
        .await
        .expect("should read torrent");

    // Assert
    let created_by = torrent.created_by().expect("should have created by");
    assert!(
        created_by.starts_with("caesura "),
        "unexpected created by: {created_by}"
    );
}

#[tokio::test]
async fn read_source_torrent_has_files() {
    // Arrange
    let album = AlbumProvider::get(SampleFormat::default()).await;
    let path = SAMPLE_SOURCES_DIR.join(album.torrent_filename());

    // Act
    let torrent = TorrentReader::execute(&path)
        .await
        .expect("should read torrent");

    // Assert
    let files = torrent
        .files
        .as_ref()
        .expect("should be multi-file torrent");
    assert!(!files.is_empty(), "torrent should contain files");
    let flac_count = files
        .iter()
        .filter(|f| f.path.extension().is_some_and(|ext| ext == "flac"))
        .count();
    assert_eq!(flac_count, album.tracks.len());
}

#[tokio::test]
async fn read_transcode_torrent() {
    // Arrange
    init_logger();
    let config = TranscodeProvider::get(SampleFormat::FLAC16_441, TargetFormat::_320).await;
    let path = config.torrent_path();

    // Act
    let torrent = TorrentReader::execute(&path)
        .await
        .expect("should read torrent");

    // Assert
    assert_eq!(torrent.name, config.dir_name());
    assert!(torrent.is_private());
    assert_eq!(torrent.source(), Some("RED"));
    let files = torrent
        .files
        .as_ref()
        .expect("should be multi-file torrent");
    let mp3_count = files
        .iter()
        .filter(|f| f.path.extension().is_some_and(|ext| ext == "mp3"))
        .count();
    assert!(mp3_count > 0, "torrent should contain mp3 files");
}

#[tokio::test]
async fn read_nonexistent_torrent_returns_error() {
    // Arrange
    let path = PathBuf::from("/nonexistent/path.torrent");

    // Act
    let result = TorrentReader::execute(&path).await;

    // Assert
    assert!(result.is_err());
}