ossify 0.4.0

A modern, easy-to-use, and reqwest-powered Rust SDK for Alibaba Cloud Object Storage Service (OSS)
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

//! CreateCnameToken.
//!
//! Official document: <https://www.alibabacloud.com/help/en/oss/developer-reference/createcnametoken>

use std::future::Future;

use http::Method;
use serde::{Deserialize, Serialize};

use crate::body::XMLBody;
use crate::error::Result;
use crate::response::BodyResponseProcessor;
use crate::ser::OnlyKeyField;
use crate::{Client, Ops, Prepared, Request};

#[derive(Debug, Clone, Serialize)]
pub struct CreateCnameTokenParams {
    cname: OnlyKeyField,
    comp: String,
}

impl Default for CreateCnameTokenParams {
    fn default() -> Self {
        Self {
            cname: OnlyKeyField,
            comp: "token".to_string(),
        }
    }
}

/// Request body: `<BucketCnameConfiguration><Cname><Domain>...</Domain></Cname></BucketCnameConfiguration>`.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename = "BucketCnameConfiguration", rename_all = "PascalCase")]
pub struct CreateCnameTokenBody {
    pub cname: CnameDomain,
}

/// `<Cname>` container that holds just the domain name.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename = "Cname", rename_all = "PascalCase")]
pub struct CnameDomain {
    pub domain: String,
}

/// Response body: `<CnameToken>`.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename = "CnameToken", rename_all = "PascalCase")]
pub struct CnameToken {
    pub bucket: String,
    pub cname: String,
    pub token: String,
    pub expire_time: String,
}

pub struct CreateCnameToken {
    pub domain: String,
}

impl Ops for CreateCnameToken {
    type Response = BodyResponseProcessor<CnameToken>;
    type Body = XMLBody<CreateCnameTokenBody>;
    type Query = CreateCnameTokenParams;

    fn prepare(self) -> Result<Prepared<CreateCnameTokenParams, CreateCnameTokenBody>> {
        Ok(Prepared {
            method: Method::POST,
            query: Some(CreateCnameTokenParams::default()),
            body: Some(CreateCnameTokenBody {
                cname: CnameDomain { domain: self.domain },
            }),
            ..Default::default()
        })
    }
}

pub trait CreateCnameTokenOps {
    /// Create a CNAME token used to verify ownership of a custom domain.
    ///
    /// Official document: <https://www.alibabacloud.com/help/en/oss/developer-reference/createcnametoken>
    fn create_cname_token(&self, domain: impl Into<String>) -> impl Future<Output = Result<CnameToken>>;
}

impl CreateCnameTokenOps for Client {
    async fn create_cname_token(&self, domain: impl Into<String>) -> Result<CnameToken> {
        self.request(CreateCnameToken {
            domain: domain.into(),
        })
        .await
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn params_serialize() {
        let q = crate::ser::to_string(&CreateCnameTokenParams::default()).unwrap();
        assert_eq!(q, "cname&comp=token");
    }

    #[test]
    fn body_serializes() {
        let body = CreateCnameTokenBody {
            cname: CnameDomain {
                domain: "example.com".to_string(),
            },
        };
        let xml = quick_xml::se::to_string(&body).unwrap();
        assert!(xml.contains("<BucketCnameConfiguration>"));
        assert!(xml.contains("<Cname>"));
        assert!(xml.contains("<Domain>example.com</Domain>"));
    }

    #[test]
    fn response_round_trip() {
        let xml = r#"<?xml version="1.0" encoding="UTF-8"?>
<CnameToken>
  <Bucket>examplebucket</Bucket>
  <Cname>example.com</Cname>
  <Token>be1d49d863dea9ffeff3df7d6455****</Token>
  <ExpireTime>Wed, 23 Feb 2022 21:16:37 GMT</ExpireTime>
</CnameToken>"#;
        let parsed: CnameToken = quick_xml::de::from_str(xml).unwrap();
        assert_eq!(parsed.bucket, "examplebucket");
        assert_eq!(parsed.cname, "example.com");
        assert_eq!(parsed.token, "be1d49d863dea9ffeff3df7d6455****");
        assert_eq!(parsed.expire_time, "Wed, 23 Feb 2022 21:16:37 GMT");
    }
}