gazelle_api 0.5.0-alpha.1

Gazelle API Client
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
125
126
127
128
129
130
131
132
133
134

use crate::options::GazelleClientOptions;
use crate::GazelleClient;
use log::info;
use rogue_config::{OptionsProvider, YamlOptionsProvider};
use rogue_logging::{Error, Logger};
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize)]
struct ExampleValues {
    pub torrent: u32,
    pub group: u32,
    pub user: u32,
}

fn get_options() -> Result<Vec<(GazelleClientOptions, ExampleValues)>, Error> {
    let clients: Vec<GazelleClientOptions> = YamlOptionsProvider::get()?;
    let examples: Vec<ExampleValues> = YamlOptionsProvider::get()?;
    let vec = clients.into_iter().zip(examples).collect();
    Ok(vec)
}

#[tokio::test]
async fn get_torrent() -> Result<(), Error> {
    // Arrange
    Logger::force_init("gazelle_api".to_owned());
    for (options, example) in get_options()? {
        println!("Indexer: {}", options.name);
        let mut client = GazelleClient::from_options(options);

        // Act
        let response = client.get_torrent(example.torrent).await?;

        // Assert
        assert_eq!(response.torrent.id, example.torrent);
    }
    Ok(())
}

#[tokio::test]
#[allow(clippy::panic)]
async fn get_torrent_invalid() -> Result<(), Error> {
    // Arrange
    Logger::force_init("gazelle_api".to_owned());
    let id = u32::MAX;
    let options: Vec<GazelleClientOptions> = YamlOptionsProvider::get()?;
    for options in options {
        info!("Indexer: {}", options.name);
        let mut client = GazelleClient::from_options(options.clone());

        // Act
        let response = client.get_torrent(id).await;

        // Assert
        match response {
            Ok(_) => panic!("should be an error"),
            Err(e) => {
                assert_eq!(e.action, "get torrent");
                if options.name == *"red" {
                    assert_eq!(e.status_code, Some(400));
                    assert_eq!(e.message, "bad id parameter".to_owned());
                } else {
                    assert_eq!(e.status_code, Some(200));
                    assert_eq!(e.message, "bad parameters".to_owned());
                }
            }
        }
    }
    Ok(())
}

#[tokio::test]
async fn get_torrent_group() -> Result<(), Error> {
    // Arrange
    Logger::force_init("gazelle_api".to_owned());
    for (options, example) in get_options()? {
        info!("Indexer: {}", options.name);
        let mut client = GazelleClient::from_options(options);

        // Act
        let response = client.get_torrent_group(example.group).await?;

        // Assert
        assert_eq!(response.group.id, example.group);
    }
    Ok(())
}

#[tokio::test]
#[allow(clippy::panic)]
async fn get_torrent_group_invalid() -> Result<(), Error> {
    // Arrange
    Logger::force_init("gazelle_api".to_owned());
    let id = u32::MAX;
    for (options, _example) in get_options()? {
        info!("Indexer: {}", options.name);
        let mut client = GazelleClient::from_options(options.clone());

        // Act
        let response = client.get_torrent_group(id).await;

        // Assert
        match response {
            Ok(_) => panic!("should be an error"),
            Err(e) => {
                assert_eq!(e.action, "get torrent group");
                if options.name == *"red" {
                    assert_eq!(e.status_code, Some(400));
                    assert_eq!(e.message, "bad id parameter".to_owned());
                } else {
                    assert_eq!(e.status_code, Some(200));
                    assert_eq!(e.message, "bad parameters".to_owned());
                }
            }
        }
    }
    Ok(())
}

#[tokio::test]
async fn get_user() -> Result<(), Error> {
    // Arrange
    Logger::force_init("gazelle_api".to_owned());
    for (options, example) in get_options()? {
        println!("Indexer: {}", options.name);
        let mut client = GazelleClient::from_options(options);

        // Act
        let user = client.get_user(example.user).await?;

        // Assert
        assert!(!user.username.is_empty());
    }
    Ok(())
}