rustnao 0.4.0

A Rust implementation of a wrapper for the SauceNAO API.
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
135
136
137
138
139
140
141

use rustnao::{Handler, HandlerBuilder, Sauce};

const FILE: &str = "https://i.imgur.com/W42kkKS.jpg";
const LOCAL_FILE: &str = "./tests/test.jpg";

/// Creates a handler for testing purposes
fn create_handler(
    dbmask: Vec<u32>, dbmaski: Vec<u32>, db_option: Option<u32>, numres: u32,
) -> Handler {
    let mut api_key = "".to_string();

    let data = std::fs::read_to_string("config.json");
    if let Ok(val) = data {
        let json: serde_json::Value =
            serde_json::from_str(val.as_str()).expect("JSON not well formatted.");
        let json_api_key = json["api_key"].as_str();

        if let Some(key) = json_api_key {
            api_key = key.to_string();
        }
    }

    match db_option {
        Some(db) => HandlerBuilder::default()
            .db_mask(dbmask)
            .db_mask_i(dbmaski)
            .db(db)
            .num_results(numres)
            .api_key(api_key.as_str())
            .build(),
        None => HandlerBuilder::default()
            .db_mask(dbmask)
            .db_mask_i(dbmaski)
            .num_results(numres)
            .api_key(api_key.as_str())
            .build(),
    }
}

/// Tests handler creation
#[test]
fn test_check_handler_creation() {
    create_handler([].to_vec(), [].to_vec(), Some(999), 999);
}

/// Tests short and long limit checks (which should change after a search)
#[test]
fn test_get_short_and_long_limits() {
    let handle = create_handler([].to_vec(), [].to_vec(), Some(999), 999);
    let cur_short_before = handle.get_current_short_limit();
    let cur_long_before = handle.get_current_long_limit();
    let result = handle.get_sauce(FILE, None, None);
    if result.is_ok() {
        assert!(cur_short_before > handle.get_current_short_limit());
        assert!(cur_long_before > handle.get_current_long_limit());
    }
}

/// Tests searching for filtering empty sourced URLs
#[test]
fn test_filter_empty_sauce() {
    let handle = create_handler([].to_vec(), [].to_vec(), Some(999), 999);
    let vec: rustnao::Result<Vec<Sauce>> = handle.get_sauce(FILE, None, None);
    if let Ok(vec_unwrap) = vec {
        let only_empty: Vec<Sauce> = vec_unwrap
            .into_iter()
            .filter(|sauce| !sauce.has_empty_url())
            .collect();
        for o in only_empty {
            assert!(!o.ext_urls.is_empty());
        }
    }
}

/// Tests local searching (local file)
#[test]
fn test_local() {
    let handle = create_handler([].to_vec(), [].to_vec(), Some(999), 2);
    let vec = handle.get_sauce_as_json(LOCAL_FILE, None, None);
    match vec {
        Ok(result) => println!("Passed, {}", result),
        Err(result) => println!(
            "
         out, {}",
            result
        ),
    }
}

/// Tests setting a max number of results
#[test]
fn test_limiting() {
    let handle = create_handler([].to_vec(), [].to_vec(), Some(999), 2);
    let vec = handle.get_sauce(FILE, None, None);
    if let Ok(vec_unwrap) = vec {
        assert!(vec_unwrap.len() <= 2);
    }
}

/// Tests db bit masks
#[test]
fn test_db_bit_mask() {
    let handle = create_handler([27].to_vec(), [].to_vec(), None, 999);
    let vec = handle.get_sauce(FILE, None, None);
    if let Ok(vec_unwrap) = vec {
        for v in vec_unwrap {
            assert!(v.index >= 27, "saw {}", v.index);
        }
    }
}

/// Tests db bit mask for exclusion
#[test]
fn test_db_bit_mask_i() {
    let handle = create_handler(
        [].to_vec(),
        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10].to_vec(),
        None,
        999,
    );
    let vec = handle.get_sauce(FILE, None, None);
    if let Ok(vec_unwrap) = vec {
        for v in vec_unwrap {
            assert!(v.index >= 11);
        }
    }
}

/// Tests min similarity and capping the number of results
#[test]
fn test_min_similarity_and_num_results() {
    let handle = create_handler([].to_vec(), [].to_vec(), Some(999), 2);
    let vec = handle.get_sauce(LOCAL_FILE, Some(5), Some(50_f64));
    if let Ok(vec_unwrap) = vec {
        let res = vec_unwrap;
        assert!(res.len() <= 5);
        for v in res {
            assert!(v.similarity >= 49.0);
        }
    }
}