zotero-api-rs 1.0.0

A secure, typed Rust client for the Zotero Web API v3
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

//! Interprets upload-authorization responses.

use crate::client::ZoteroClientError;
use crate::types::file_upload::FileUploadAuthorizationResponse;

/// Next action to take after file-upload authorization.
#[derive(Clone, Debug)]
pub enum FileUploadAction {
    /// No upload needed because the same file already exists.
    AlreadyExists,
    /// Upload binary then register with Zotero.
    UploadRequired {
        /// Upload key returned by Zotero.
        upload_key: String,
        /// Target URL to receive the multipart-like byte payload.
        upload_url: String,
        /// Prefix wrapper bytes, UTF-8 encoded.
        prefix: String,
        /// Suffix wrapper bytes, UTF-8 encoded.
        suffix: String,
    },
}

/// Determines the required next upload step from the authorization response.
pub fn determine_upload_action(
    response: &FileUploadAuthorizationResponse,
) -> Result<FileUploadAction, ZoteroClientError> {
    if response.exists == 1 {
        return Ok(FileUploadAction::AlreadyExists);
    }

    let upload_key = response
        .upload_key
        .as_ref()
        .ok_or_else(|| ZoteroClientError::InvalidFileUploadResponse("upload_key".into()))?;
    let upload_url = response
        .url
        .as_ref()
        .ok_or_else(|| ZoteroClientError::InvalidFileUploadResponse("url".into()))?;
    let prefix = response
        .prefix
        .as_ref()
        .ok_or_else(|| ZoteroClientError::InvalidFileUploadResponse("prefix".into()))?;
    let suffix = response
        .suffix
        .as_ref()
        .ok_or_else(|| ZoteroClientError::InvalidFileUploadResponse("suffix".into()))?;

    Ok(FileUploadAction::UploadRequired {
        upload_key: upload_key.clone(),
        upload_url: upload_url.clone(),
        prefix: prefix.clone(),
        suffix: suffix.clone(),
    })
}

#[cfg(test)]
mod tests {
    use crate::api::file_upload::determine_upload_action::{
        determine_upload_action, FileUploadAction,
    };
    use crate::types::file_upload::FileUploadAuthorizationResponse;

    #[test]
    fn returns_already_exists_when_exists_is_one() {
        let response = FileUploadAuthorizationResponse {
            exists: 1,
            upload_key: None,
            url: None,
            prefix: None,
            suffix: None,
        };

        let action = determine_upload_action(&response).expect("valid");
        assert!(matches!(action, FileUploadAction::AlreadyExists));
    }

    #[test]
    fn fails_when_upload_required_but_missing_fields() {
        let response = FileUploadAuthorizationResponse {
            exists: 0,
            upload_key: Some("ukey".to_owned()),
            url: None,
            prefix: Some("p".to_owned()),
            suffix: Some("s".to_owned()),
        };

        let err = determine_upload_action(&response).expect_err("must fail");
        assert!(format!("{err}").contains("missing file upload field"));
    }

    #[test]
    fn returns_upload_required_when_all_fields_present() {
        let response = FileUploadAuthorizationResponse {
            exists: 0,
            upload_key: Some("u".to_owned()),
            url: Some("https://example.com/upload".to_owned()),
            prefix: Some("p".to_owned()),
            suffix: Some("s".to_owned()),
        };

        let action = determine_upload_action(&response).expect("must parse");
        assert!(matches!(action, FileUploadAction::UploadRequired { .. }));
    }
}