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
131
132
133
134

//! GetBucketAcl: query the access control list of a bucket.
//!
//! Official document: <https://www.alibabacloud.com/help/en/oss/developer-reference/getbucketacl>

use std::future::Future;

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

use crate::body::NoneBody;
use crate::error::Result;
use crate::ops::common::{BucketAcl, Owner};
use crate::response::BodyResponseProcessor;
use crate::ser::OnlyKeyField;
use crate::{Client, Ops, Prepared, Request};

#[derive(Debug, Clone, Default, Serialize)]
pub struct GetBucketAclParams {
    acl: OnlyKeyField,
}

/// XML `<AccessControlList>` element.
#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "PascalCase")]
pub struct AccessControlList {
    /// The canned ACL value currently applied to the bucket.
    pub grant: BucketAcl,
}

/// Response body for [`GetBucketAcl`] (XML root `<AccessControlPolicy>`).
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct AccessControlPolicy {
    /// Bucket owner information.
    pub owner: Owner,
    /// The ACL applied to the bucket.
    pub access_control_list: AccessControlList,
}

/// The `GetBucketAcl` operation.
pub struct GetBucketAcl;

impl Ops for GetBucketAcl {
    type Response = BodyResponseProcessor<AccessControlPolicy>;
    type Body = NoneBody;
    type Query = GetBucketAclParams;

    fn prepare(self) -> Result<Prepared<GetBucketAclParams>> {
        Ok(Prepared {
            method: Method::GET,
            query: Some(GetBucketAclParams::default()),
            ..Default::default()
        })
    }
}

pub trait GetBucketAclOps {
    /// Query the ACL of the bucket.
    ///
    /// Official document: <https://www.alibabacloud.com/help/en/oss/developer-reference/getbucketacl>
    fn get_bucket_acl(&self) -> impl Future<Output = Result<AccessControlPolicy>>;
}

impl GetBucketAclOps for Client {
    async fn get_bucket_acl(&self) -> Result<AccessControlPolicy> {
        self.request(GetBucketAcl).await
    }
}

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

    #[test]
    fn params_serialize_adds_acl_subresource() {
        let q = crate::ser::to_string(&GetBucketAclParams::default()).unwrap();
        assert_eq!(q, "acl");
    }

    #[test]
    fn prepared_uses_get() {
        let prepared = GetBucketAcl.prepare().unwrap();
        assert_eq!(prepared.method, Method::GET);
        assert!(prepared.body.is_none());
    }

    #[test]
    fn parse_sample_response() {
        let xml = r#"<?xml version="1.0"?>
<AccessControlPolicy>
    <Owner>
        <ID>0022012****</ID>
        <DisplayName>user_example</DisplayName>
    </Owner>
    <AccessControlList>
        <Grant>public-read</Grant>
    </AccessControlList>
</AccessControlPolicy>"#;
        let parsed: AccessControlPolicy = quick_xml::de::from_str(xml).unwrap();
        assert_eq!(parsed.owner.id.as_deref(), Some("0022012****"));
        assert_eq!(parsed.owner.display_name.as_deref(), Some("user_example"));
        assert_eq!(parsed.access_control_list.grant, BucketAcl::PublicRead);
    }

    #[test]
    fn parse_private_acl() {
        let xml = r#"<AccessControlPolicy>
    <Owner>
        <ID>x</ID>
        <DisplayName>x</DisplayName>
    </Owner>
    <AccessControlList>
        <Grant>private</Grant>
    </AccessControlList>
</AccessControlPolicy>"#;
        let parsed: AccessControlPolicy = quick_xml::de::from_str(xml).unwrap();
        assert_eq!(parsed.access_control_list.grant, BucketAcl::Private);
    }

    #[test]
    fn parse_public_read_write_acl() {
        let xml = r#"<AccessControlPolicy>
    <Owner>
        <ID>x</ID>
        <DisplayName>x</DisplayName>
    </Owner>
    <AccessControlList>
        <Grant>public-read-write</Grant>
    </AccessControlList>
</AccessControlPolicy>"#;
        let parsed: AccessControlPolicy = quick_xml::de::from_str(xml).unwrap();
        assert_eq!(parsed.access_control_list.grant, BucketAcl::PublicReadWrite);
    }
}