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
135
136
137
138
139
140
141
142
143
144
145
146

//! ListResourcePools: list all resource pools owned by the current account.
//!
//! Official document: <https://www.alibabacloud.com/help/en/oss/developer-reference/listresourcepools>

use std::future::Future;

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

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

#[skip_serializing_none]
#[derive(Debug, Clone, Default, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct ListResourcePoolsParams {
    #[serde(rename = "resourcePool")]
    resource_pool: OnlyKeyField,

    pub continuation_token: Option<String>,
    pub max_keys: Option<u32>,
}

impl ListResourcePoolsParams {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn continuation_token(mut self, token: impl Into<String>) -> Self {
        self.continuation_token = Some(token.into());
        self
    }

    pub fn max_keys(mut self, max_keys: u32) -> Self {
        self.max_keys = Some(max_keys);
        self
    }
}

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct ListResourcePoolsResult {
    pub region: Option<String>,
    pub owner: Option<String>,
    pub continuation_token: Option<String>,
    pub next_continuation_token: Option<String>,
    #[serde(default)]
    pub is_truncated: bool,
    #[serde(default, rename = "ResourcePool")]
    pub resource_pools: Vec<ResourcePool>,
}

pub struct ListResourcePools {
    pub params: ListResourcePoolsParams,
}

impl Ops for ListResourcePools {
    type Response = BodyResponseProcessor<ListResourcePoolsResult>;
    type Body = NoneBody;
    type Query = ListResourcePoolsParams;

    const USE_BUCKET: bool = false;

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

pub trait ListResourcePoolsOps {
    /// List all resource pools owned by the current account.
    ///
    /// Official document: <https://www.alibabacloud.com/help/en/oss/developer-reference/listresourcepools>
    fn list_resource_pools(
        &self,
        params: Option<ListResourcePoolsParams>,
    ) -> impl Future<Output = Result<ListResourcePoolsResult>>;
}

impl ListResourcePoolsOps for Client {
    async fn list_resource_pools(
        &self,
        params: Option<ListResourcePoolsParams>,
    ) -> Result<ListResourcePoolsResult> {
        self.request(ListResourcePools {
            params: params.unwrap_or_default(),
        })
        .await
    }
}

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

    #[test]
    fn params_serialize_defaults() {
        assert_eq!(crate::ser::to_string(&ListResourcePoolsParams::new()).unwrap(), "resourcePool");
    }

    #[test]
    fn params_serialize_with_pagination() {
        let q = crate::ser::to_string(
            &ListResourcePoolsParams::new()
                .continuation_token("abc")
                .max_keys(5),
        )
        .unwrap();
        assert_eq!(q, "continuation-token=abc&max-keys=5&resourcePool");
    }

    #[test]
    fn use_bucket_is_false() {
        const _: () = assert!(!<ListResourcePools as Ops>::USE_BUCKET);
    }

    #[test]
    fn parse_response() {
        let xml = r#"<?xml version="1.0" encoding="UTF-8"?>
<ListResourcePoolsResult>
  <Region>oss-cn-hangzhou</Region>
  <Owner>103xxxx</Owner>
  <IsTruncated>false</IsTruncated>
  <ResourcePool>
    <Name>rp-for-ai</Name>
    <CreateTime>2024-11-29T08:42:32.000Z</CreateTime>
  </ResourcePool>
  <ResourcePool>
    <Name>rp-for-etl</Name>
    <CreateTime>2024-12-01T10:00:00.000Z</CreateTime>
  </ResourcePool>
</ListResourcePoolsResult>"#;
        let parsed: ListResourcePoolsResult = quick_xml::de::from_str(xml).unwrap();
        assert_eq!(parsed.region.as_deref(), Some("oss-cn-hangzhou"));
        assert_eq!(parsed.resource_pools.len(), 2);
        assert_eq!(parsed.resource_pools[0].name, "rp-for-ai");
    }
}