Add more APIs (#25)

* {set,get,delete}_bucket_notification
* {set,get,delete}_bucket_policy
* {set,get,delete}_bucket_replication
* {set,get,delete}_bucket_tags
* {set,get,delete}_object_lock_config
* {set,get,delete}_object_tags
* {set,get}_bucket_versioning
* {set,get}_object_retention
* get_presigned_object_url
* get_presigned_post_form_data
* {upload,download}_object

Signed-off-by: Bala.FA <bala@minio.io>

README.md

@@ -1,6 +1,62 @@
-# MinIO Rust SDK for Amazon S3 Compatible Cloud Storage [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)
+# MinIO Rust SDK for Amazon S3 Compatible Cloud Storage [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io) [![Sourcegraph](https://sourcegraph.com/github.com/minio/minio-rs/-/badge.svg)](https://sourcegraph.com/github.com/minio/minio-rs?badge) [![Apache V2 License](https://img.shields.io/badge/license-Apache%20V2-blue.svg)](https://github.com/minio/minio-rs/blob/master/LICENSE)
+
+MinIO Rust SDK is Simple Storage Service (aka S3) client to perform bucket and object operations to any Amazon S3 compatible object storage service.
+
+For a complete list of APIs and examples, please take a look at the [MinIO Rust Client API Reference](https://minio-rs.min.io/)
+
+## Example:: file-uploader.rs
+```rust
+use minio::s3::args::{BucketExistsArgs, MakeBucketArgs, UploadObjectArgs};
+use minio::s3::client::Client;
+use minio::s3::creds::StaticProvider;
+use minio::s3::http::BaseUrl;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    let mut base_url = BaseUrl::from_string("play.min.io").unwrap();
+    base_url.https = true;
+
+    let static_provider = StaticProvider::new(
+        "Q3AM3UQ867SPQQA43P2F",
+        "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG",
+        None,
+    );
+
+    let mut client = Client::new(base_url.clone(), Some(static_provider));
+
+    let bucket_name = "asiatrip";
+
+    // Check 'asiatrip' bucket exist or not.
+    let exists = client
+        .bucket_exists(&BucketExistsArgs::new(&bucket_name).unwrap())
+        .await
+        .unwrap();
+
+    // Make 'asiatrip' bucket if not exist.
+    if !exist {
+        client
+            .make_bucket(&MakeBucketArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+    }
+
+    // Upload '/home/user/Photos/asiaphotos.zip' as object name
+    // 'asiaphotos-2015.zip' to bucket 'asiatrip'.
+    client
+        .upload_object(
+            &mut UploadObjectArgs::new(
+                &bucket_name,
+                "asiaphotos-2015.zip",
+                "/home/user/Photos/asiaphotos.zip",
+            )
+            .unwrap(),
+        )
+        .await
+        .unwrap();
+
+    println!("'/home/user/Photos/asiaphotos.zip' is successfully uploaded as object 'asiaphotos-2015.zip' to bucket 'asiatrip'.");
+}
+```
 
 ## License
-MinIO Rust SDK is distributed under the terms of the Apache 2.0 license.
+This SDK is distributed under the [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0), see [LICENSE](https://github.com/minio/minio-rs/blob/master/LICENSE) for more information.
-
-See [LICENSE](LICENSE) for details.

src/s3/args.rs

@@ -14,27 +14,34 @@
 // limitations under the License.
 
 use crate::s3::error::Error;
+use crate::s3::signer::post_presign_v4;
 use crate::s3::sse::{Sse, SseCustomerKey};
 use crate::s3::types::{
-    DeleteObject, Directive, Item, LifecycleConfig, NotificationRecords, Part, Retention,
+    DeleteObject, Directive, Item, LifecycleConfig, NotificationConfig, NotificationRecords,
-    SelectRequest, SseConfig,
+    ObjectLockConfig, Part, ReplicationConfig, Retention, RetentionMode, SelectRequest, SseConfig,
 };
 use crate::s3::utils::{
-    check_bucket_name, merge, to_http_header_value, to_iso8601utc, urlencode, Multimap, UtcTime,
+    b64encode, check_bucket_name, merge, to_amz_date, to_http_header_value, to_iso8601utc,
+    to_signer_date, urlencode, utc_now, Multimap, UtcTime,
 };
 use derivative::Derivative;
+use hyper::http::Method;
+use serde_json::json;
+use serde_json::Value;
+use std::collections::HashMap;
 
 pub const MIN_PART_SIZE: usize = 5_242_880; // 5 MiB
 pub const MAX_PART_SIZE: usize = 5_368_709_120; // 5 GiB
 pub const MAX_OBJECT_SIZE: usize = 5_497_558_138_880; // 5 TiB
 pub const MAX_MULTIPART_COUNT: u16 = 10_000;
+pub const DEFAULT_EXPIRY_SECONDS: u32 = 604_800; // 7 days
 
 fn object_write_args_headers(
     extra_headers: Option<&Multimap>,
     headers: Option<&Multimap>,
     user_metadata: Option<&Multimap>,
     sse: Option<&dyn Sse>,
-    tags: Option<&std::collections::HashMap<String, String>>,
+    tags: Option<&HashMap<String, String>>,
     retention: Option<&Retention>,
     legal_hold: bool,
 ) -> Multimap {
@@ -397,7 +404,7 @@ pub struct PutObjectApiArgs<'a> {
     pub headers: Option<&'a Multimap>,
     pub user_metadata: Option<&'a Multimap>,
     pub sse: Option<&'a dyn Sse>,
-    pub tags: Option<&'a std::collections::HashMap<String, String>>,
+    pub tags: Option<&'a HashMap<String, String>>,
     pub retention: Option<&'a Retention>,
     pub legal_hold: bool,
     pub data: &'a [u8],
@@ -458,7 +465,7 @@ pub struct UploadPartArgs<'a> {
     pub headers: Option<&'a Multimap>,
     pub user_metadata: Option<&'a Multimap>,
     pub sse: Option<&'a dyn Sse>,
-    pub tags: Option<&'a std::collections::HashMap<String, String>>,
+    pub tags: Option<&'a HashMap<String, String>>,
     pub retention: Option<&'a Retention>,
     pub legal_hold: bool,
     pub upload_id: &'a str,
@@ -534,7 +541,7 @@ pub struct PutObjectArgs<'a> {
     pub headers: Option<&'a Multimap>,
     pub user_metadata: Option<&'a Multimap>,
     pub sse: Option<&'a dyn Sse>,
-    pub tags: Option<&'a std::collections::HashMap<String, String>>,
+    pub tags: Option<&'a HashMap<String, String>>,
     pub retention: Option<&'a Retention>,
     pub legal_hold: bool,
     pub object_size: Option<usize>,
@@ -1090,7 +1097,7 @@ pub struct CopyObjectArgs<'a> {
     pub headers: Option<&'a Multimap>,
     pub user_metadata: Option<&'a Multimap>,
     pub sse: Option<&'a dyn Sse>,
-    pub tags: Option<&'a std::collections::HashMap<String, String>>,
+    pub tags: Option<&'a HashMap<String, String>>,
     pub retention: Option<&'a Retention>,
     pub legal_hold: bool,
     pub source: CopySource<'a>,
@@ -1297,7 +1304,7 @@ pub struct ComposeObjectArgs<'a> {
     pub headers: Option<&'a Multimap>,
     pub user_metadata: Option<&'a Multimap>,
     pub sse: Option<&'a dyn Sse>,
-    pub tags: Option<&'a std::collections::HashMap<String, String>>,
+    pub tags: Option<&'a HashMap<String, String>>,
     pub retention: Option<&'a Retention>,
     pub legal_hold: bool,
     pub sources: &'a mut Vec<ComposeSource<'a>>,
@@ -1393,3 +1400,589 @@ pub struct SetBucketLifecycleArgs<'a> {
     pub bucket: &'a str,
     pub config: &'a LifecycleConfig,
 }
+
+pub type DeleteBucketNotificationArgs<'a> = BucketArgs<'a>;
+
+pub type GetBucketNotificationArgs<'a> = BucketArgs<'a>;
+
+pub struct SetBucketNotificationArgs<'a> {
+    pub extra_headers: Option<&'a Multimap>,
+    pub extra_query_params: Option<&'a Multimap>,
+    pub region: Option<&'a str>,
+    pub bucket: &'a str,
+    pub config: &'a NotificationConfig,
+}
+
+impl<'a> SetBucketNotificationArgs<'a> {
+    pub fn new(
+        bucket_name: &'a str,
+        config: &'a NotificationConfig,
+    ) -> Result<SetBucketNotificationArgs<'a>, Error> {
+        check_bucket_name(bucket_name, true)?;
+
+        Ok(SetBucketNotificationArgs {
+            extra_headers: None,
+            extra_query_params: None,
+            region: None,
+            bucket: bucket_name,
+            config: config,
+        })
+    }
+}
+
+pub type DeleteBucketPolicyArgs<'a> = BucketArgs<'a>;
+
+pub type GetBucketPolicyArgs<'a> = BucketArgs<'a>;
+
+pub struct SetBucketPolicyArgs<'a> {
+    pub extra_headers: Option<&'a Multimap>,
+    pub extra_query_params: Option<&'a Multimap>,
+    pub region: Option<&'a str>,
+    pub bucket: &'a str,
+    pub config: &'a str,
+}
+
+impl<'a> SetBucketPolicyArgs<'a> {
+    pub fn new(bucket_name: &'a str, config: &'a str) -> Result<SetBucketPolicyArgs<'a>, Error> {
+        check_bucket_name(bucket_name, true)?;
+
+        Ok(SetBucketPolicyArgs {
+            extra_headers: None,
+            extra_query_params: None,
+            region: None,
+            bucket: bucket_name,
+            config: config,
+        })
+    }
+}
+
+pub type DeleteBucketReplicationArgs<'a> = BucketArgs<'a>;
+
+pub type GetBucketReplicationArgs<'a> = BucketArgs<'a>;
+
+pub struct SetBucketReplicationArgs<'a> {
+    pub extra_headers: Option<&'a Multimap>,
+    pub extra_query_params: Option<&'a Multimap>,
+    pub region: Option<&'a str>,
+    pub bucket: &'a str,
+    pub config: &'a ReplicationConfig,
+}
+
+pub type DeleteBucketTagsArgs<'a> = BucketArgs<'a>;
+
+pub type GetBucketTagsArgs<'a> = BucketArgs<'a>;
+
+pub struct SetBucketTagsArgs<'a> {
+    pub extra_headers: Option<&'a Multimap>,
+    pub extra_query_params: Option<&'a Multimap>,
+    pub region: Option<&'a str>,
+    pub bucket: &'a str,
+    pub tags: &'a HashMap<String, String>,
+}
+
+impl<'a> SetBucketTagsArgs<'a> {
+    pub fn new(
+        bucket_name: &'a str,
+        tags: &'a HashMap<String, String>,
+    ) -> Result<SetBucketTagsArgs<'a>, Error> {
+        check_bucket_name(bucket_name, true)?;
+
+        Ok(SetBucketTagsArgs {
+            extra_headers: None,
+            extra_query_params: None,
+            region: None,
+            bucket: bucket_name,
+            tags: tags,
+        })
+    }
+}
+
+pub type GetBucketVersioningArgs<'a> = BucketArgs<'a>;
+
+pub struct SetBucketVersioningArgs<'a> {
+    pub extra_headers: Option<&'a Multimap>,
+    pub extra_query_params: Option<&'a Multimap>,
+    pub region: Option<&'a str>,
+    pub bucket: &'a str,
+    pub status: bool,
+    pub mfa_delete: Option<bool>,
+}
+
+impl<'a> SetBucketVersioningArgs<'a> {
+    pub fn new(bucket_name: &'a str, status: bool) -> Result<SetBucketVersioningArgs<'a>, Error> {
+        check_bucket_name(bucket_name, true)?;
+
+        Ok(SetBucketVersioningArgs {
+            extra_headers: None,
+            extra_query_params: None,
+            region: None,
+            bucket: bucket_name,
+            status: status,
+            mfa_delete: None,
+        })
+    }
+}
+
+pub type DeleteObjectLockConfigArgs<'a> = BucketArgs<'a>;
+
+pub type GetObjectLockConfigArgs<'a> = BucketArgs<'a>;
+
+pub struct SetObjectLockConfigArgs<'a> {
+    pub extra_headers: Option<&'a Multimap>,
+    pub extra_query_params: Option<&'a Multimap>,
+    pub region: Option<&'a str>,
+    pub bucket: &'a str,
+    pub config: &'a ObjectLockConfig,
+}
+
+impl<'a> SetObjectLockConfigArgs<'a> {
+    pub fn new(
+        bucket_name: &'a str,
+        config: &'a ObjectLockConfig,
+    ) -> Result<SetObjectLockConfigArgs<'a>, Error> {
+        check_bucket_name(bucket_name, true)?;
+
+        Ok(SetObjectLockConfigArgs {
+            extra_headers: None,
+            extra_query_params: None,
+            region: None,
+            bucket: bucket_name,
+            config: config,
+        })
+    }
+}
+
+pub type GetObjectRetentionArgs<'a> = ObjectVersionArgs<'a>;
+
+pub struct SetObjectRetentionArgs<'a> {
+    pub extra_headers: Option<&'a Multimap>,
+    pub extra_query_params: Option<&'a Multimap>,
+    pub region: Option<&'a str>,
+    pub bucket: &'a str,
+    pub object: &'a str,
+    pub version_id: Option<&'a str>,
+    pub bypass_governance_mode: bool,
+    pub retention_mode: Option<RetentionMode>,
+    pub retain_until_date: Option<UtcTime>,
+}
+
+impl<'a> SetObjectRetentionArgs<'a> {
+    pub fn new(
+        bucket_name: &'a str,
+        object_name: &'a str,
+    ) -> Result<SetObjectRetentionArgs<'a>, Error> {
+        check_bucket_name(bucket_name, true)?;
+
+        if object_name.is_empty() {
+            return Err(Error::InvalidObjectName(String::from(
+                "object name cannot be empty",
+            )));
+        }
+
+        Ok(SetObjectRetentionArgs {
+            extra_headers: None,
+            extra_query_params: None,
+            region: None,
+            bucket: bucket_name,
+            object: object_name,
+            version_id: None,
+            bypass_governance_mode: false,
+            retention_mode: None,
+            retain_until_date: None,
+        })
+    }
+}
+
+pub type DeleteObjectTagsArgs<'a> = ObjectVersionArgs<'a>;
+
+pub type GetObjectTagsArgs<'a> = ObjectVersionArgs<'a>;
+
+pub struct SetObjectTagsArgs<'a> {
+    pub extra_headers: Option<&'a Multimap>,
+    pub extra_query_params: Option<&'a Multimap>,
+    pub region: Option<&'a str>,
+    pub bucket: &'a str,
+    pub object: &'a str,
+    pub version_id: Option<&'a str>,
+    pub tags: &'a HashMap<String, String>,
+}
+
+impl<'a> SetObjectTagsArgs<'a> {
+    pub fn new(
+        bucket_name: &'a str,
+        object_name: &'a str,
+        tags: &'a HashMap<String, String>,
+    ) -> Result<SetObjectTagsArgs<'a>, Error> {
+        check_bucket_name(bucket_name, true)?;
+
+        if object_name.is_empty() {
+            return Err(Error::InvalidObjectName(String::from(
+                "object name cannot be empty",
+            )));
+        }
+
+        Ok(SetObjectTagsArgs {
+            extra_headers: None,
+            extra_query_params: None,
+            region: None,
+            bucket: bucket_name,
+            object: object_name,
+            version_id: None,
+            tags: tags,
+        })
+    }
+}
+
+pub struct GetPresignedObjectUrlArgs<'a> {
+    pub extra_query_params: Option<&'a Multimap>,
+    pub region: Option<&'a str>,
+    pub bucket: &'a str,
+    pub object: &'a str,
+    pub version_id: Option<&'a str>,
+    pub method: Method,
+    pub expiry_seconds: Option<u32>,
+    pub request_time: Option<UtcTime>,
+}
+
+impl<'a> GetPresignedObjectUrlArgs<'a> {
+    pub fn new(
+        bucket_name: &'a str,
+        object_name: &'a str,
+        method: Method,
+    ) -> Result<GetPresignedObjectUrlArgs<'a>, Error> {
+        check_bucket_name(bucket_name, true)?;
+
+        if object_name.is_empty() {
+            return Err(Error::InvalidObjectName(String::from(
+                "object name cannot be empty",
+            )));
+        }
+
+        Ok(GetPresignedObjectUrlArgs {
+            extra_query_params: None,
+            region: None,
+            bucket: bucket_name,
+            object: object_name,
+            version_id: None,
+            method: method,
+            expiry_seconds: Some(DEFAULT_EXPIRY_SECONDS),
+            request_time: None,
+        })
+    }
+}
+
+pub struct PostPolicy<'a> {
+    pub region: Option<&'a str>,
+    pub bucket: &'a str,
+
+    expiration: &'a UtcTime,
+    eq_conditions: HashMap<String, String>,
+    starts_with_conditions: HashMap<String, String>,
+    lower_limit: Option<usize>,
+    upper_limit: Option<usize>,
+}
+
+impl<'a> PostPolicy<'a> {
+    const EQ: &str = "eq";
+    const STARTS_WITH: &str = "starts-with";
+    const ALGORITHM: &str = "AWS4-HMAC-SHA256";
+
+    pub fn new(bucket_name: &'a str, expiration: &'a UtcTime) -> Result<PostPolicy<'a>, Error> {
+        check_bucket_name(bucket_name, true)?;
+
+        Ok(PostPolicy {
+            region: None,
+            bucket: bucket_name,
+            expiration: expiration,
+            eq_conditions: HashMap::new(),
+            starts_with_conditions: HashMap::new(),
+            lower_limit: None,
+            upper_limit: None,
+        })
+    }
+
+    fn trim_dollar(value: &str) -> String {
+        let mut s = value.to_string();
+        if s.starts_with("$") {
+            s.remove(0);
+        }
+        return s;
+    }
+
+    fn is_reserved_element(element: &str) -> bool {
+        return element == "bucket"
+            || element == "x-amz-algorithm"
+            || element == "x-amz-credential"
+            || element == "x-amz-date"
+            || element == "policy"
+            || element == "x-amz-signature";
+    }
+
+    fn get_credential_string(access_key: &String, date: &UtcTime, region: &String) -> String {
+        return format!(
+            "{}/{}/{}/s3/aws4_request",
+            access_key,
+            to_signer_date(*date),
+            region
+        );
+    }
+
+    pub fn add_equals_condition(&mut self, element: &str, value: &str) -> Result<(), Error> {
+        if element.is_empty() {
+            return Err(Error::PostPolicyError(format!(
+                "condition element cannot be empty"
+            )));
+        }
+
+        let v = PostPolicy::trim_dollar(element);
+        if v == "success_action_redirect" || v == "redirect" || v == "content-length-range" {
+            return Err(Error::PostPolicyError(format!(
+                "{} is unsupported for equals condition",
+                element
+            )));
+        }
+
+        if PostPolicy::is_reserved_element(&v.as_str()) {
+            return Err(Error::PostPolicyError(format!("{} cannot set", element)));
+        }
+
+        self.eq_conditions.insert(v, value.to_string());
+        Ok(())
+    }
+
+    pub fn remove_equals_condition(&mut self, element: &str) {
+        self.eq_conditions.remove(element);
+    }
+
+    pub fn add_starts_with_condition(&mut self, element: &str, value: &str) -> Result<(), Error> {
+        if element.is_empty() {
+            return Err(Error::PostPolicyError(format!(
+                "condition element cannot be empty"
+            )));
+        }
+
+        let v = PostPolicy::trim_dollar(element);
+        if v == "success_action_status"
+            || v == "content-length-range"
+            || (v.starts_with("x-amz-") && v.starts_with("x-amz-meta-"))
+        {
+            return Err(Error::PostPolicyError(format!(
+                "{} is unsupported for starts-with condition",
+                element
+            )));
+        }
+
+        if PostPolicy::is_reserved_element(&v.as_str()) {
+            return Err(Error::PostPolicyError(format!("{} cannot set", element)));
+        }
+
+        self.starts_with_conditions
+            .insert(v.clone(), value.to_string());
+        Ok(())
+    }
+
+    pub fn remove_starts_with_condition(&mut self, element: &str) {
+        self.starts_with_conditions.remove(element);
+    }
+
+    pub fn add_content_length_range_condition(
+        &mut self,
+        lower_limit: usize,
+        upper_limit: usize,
+    ) -> Result<(), Error> {
+        if lower_limit > upper_limit {
+            return Err(Error::PostPolicyError(format!(
+                "lower limit cannot be greater than upper limit"
+            )));
+        }
+
+        self.lower_limit = Some(lower_limit);
+        self.upper_limit = Some(upper_limit);
+        Ok(())
+    }
+
+    pub fn remove_content_length_range_condition(&mut self) {
+        self.lower_limit = None;
+        self.upper_limit = None;
+    }
+
+    pub fn form_data(
+        &self,
+        access_key: String,
+        secret_key: String,
+        session_token: Option<String>,
+        region: String,
+    ) -> Result<HashMap<String, String>, Error> {
+        if region.is_empty() {
+            return Err(Error::PostPolicyError(format!("region cannot be empty")));
+        }
+
+        if !self.eq_conditions.contains_key("key")
+            && !self.starts_with_conditions.contains_key("key")
+        {
+            return Err(Error::PostPolicyError(format!("key condition must be set")));
+        }
+
+        let mut conditions: Vec<Value> = Vec::new();
+        conditions.push(json!([PostPolicy::EQ, "$bucket", self.bucket]));
+        for (key, value) in &self.eq_conditions {
+            conditions.push(json!([PostPolicy::EQ, String::from("$") + &key, value]));
+        }
+        for (key, value) in &self.starts_with_conditions {
+            conditions.push(json!([
+                PostPolicy::STARTS_WITH,
+                String::from("$") + &key,
+                value
+            ]));
+        }
+        if self.lower_limit.is_some() && self.upper_limit.is_some() {
+            conditions.push(json!([
+                "content-length-range",
+                self.lower_limit.unwrap(),
+                self.upper_limit.unwrap()
+            ]));
+        }
+
+        let date = utc_now();
+        let credential = PostPolicy::get_credential_string(&access_key, &date, &region);
+        let amz_date = to_amz_date(date);
+        conditions.push(json!([
+            PostPolicy::EQ,
+            "$x-amz-algorithm",
+            PostPolicy::ALGORITHM
+        ]));
+        conditions.push(json!([PostPolicy::EQ, "$x-amz-credential", credential]));
+        if let Some(v) = &session_token {
+            conditions.push(json!([PostPolicy::EQ, "$x-amz-security-token", v]));
+        }
+        conditions.push(json!([PostPolicy::EQ, "$x-amz-date", amz_date]));
+
+        let policy = json!({
+            "expiration": to_iso8601utc(*self.expiration),
+            "conditions": conditions,
+        });
+
+        let encoded_policy = b64encode(policy.to_string());
+        let signature = post_presign_v4(&encoded_policy, &secret_key, date, &region);
+
+        let mut data: HashMap<String, String> = HashMap::new();
+        data.insert(
+            String::from("x-amz-algorithm"),
+            String::from(PostPolicy::ALGORITHM),
+        );
+        data.insert(String::from("x-amz-credential"), credential);
+        data.insert(String::from("x-amz-date"), amz_date);
+        data.insert(String::from("policy"), encoded_policy);
+        data.insert(String::from("x-amz-signature"), signature);
+        if let Some(v) = session_token {
+            data.insert(String::from("x-amz-security-token"), v);
+        }
+
+        Ok(data)
+    }
+}
+
+pub struct DownloadObjectArgs<'a> {
+    pub extra_headers: Option<&'a Multimap>,
+    pub extra_query_params: Option<&'a Multimap>,
+    pub region: Option<&'a str>,
+    pub bucket: &'a str,
+    pub object: &'a str,
+    pub version_id: Option<&'a str>,
+    pub ssec: Option<&'a SseCustomerKey>,
+    pub filename: &'a str,
+    pub overwrite: bool,
+}
+
+impl<'a> DownloadObjectArgs<'a> {
+    pub fn new(
+        bucket_name: &'a str,
+        object_name: &'a str,
+        filename: &'a str,
+    ) -> Result<DownloadObjectArgs<'a>, Error> {
+        check_bucket_name(bucket_name, true)?;
+
+        if object_name.is_empty() {
+            return Err(Error::InvalidObjectName(String::from(
+                "object name cannot be empty",
+            )));
+        }
+
+        Ok(DownloadObjectArgs {
+            extra_headers: None,
+            extra_query_params: None,
+            region: None,
+            bucket: bucket_name,
+            object: object_name,
+            version_id: None,
+            ssec: None,
+            filename: filename,
+            overwrite: false,
+        })
+    }
+}
+
+pub struct UploadObjectArgs<'a> {
+    pub extra_headers: Option<&'a Multimap>,
+    pub extra_query_params: Option<&'a Multimap>,
+    pub region: Option<&'a str>,
+    pub bucket: &'a str,
+    pub object: &'a str,
+    pub headers: Option<&'a Multimap>,
+    pub user_metadata: Option<&'a Multimap>,
+    pub sse: Option<&'a dyn Sse>,
+    pub tags: Option<&'a HashMap<String, String>>,
+    pub retention: Option<&'a Retention>,
+    pub legal_hold: bool,
+    pub object_size: Option<usize>,
+    pub part_size: usize,
+    pub part_count: i16,
+    pub content_type: &'a str,
+    pub filename: &'a str,
+}
+
+impl<'a> UploadObjectArgs<'a> {
+    pub fn new(
+        bucket_name: &'a str,
+        object_name: &'a str,
+        filename: &'a str,
+    ) -> Result<UploadObjectArgs<'a>, Error> {
+        check_bucket_name(bucket_name, true)?;
+
+        if object_name.is_empty() {
+            return Err(Error::InvalidObjectName(String::from(
+                "object name cannot be empty",
+            )));
+        }
+
+        let meta = std::fs::metadata(filename)?;
+        if !meta.is_file() {
+            return Err(Error::IOError(std::io::Error::new(
+                std::io::ErrorKind::Other,
+                "not a file",
+            )));
+        }
+
+        let object_size = Some(meta.len() as usize);
+        let (psize, part_count) = calc_part_info(object_size, None)?;
+
+        Ok(UploadObjectArgs {
+            extra_headers: None,
+            extra_query_params: None,
+            region: None,
+            bucket: bucket_name,
+            object: object_name,
+            headers: None,
+            user_metadata: None,
+            sse: None,
+            tags: None,
+            retention: None,
+            legal_hold: false,
+            object_size: object_size,
+            part_size: psize,
+            part_count: part_count,
+            content_type: "application/octet-stream",
+            filename: filename,
+        })
+    }
+}

src/s3/error.rs

@@ -102,6 +102,8 @@ pub enum Error {
     InvalidDateAndDays(String),
     InvalidLifecycleRuleId,
     InvalidFilter,
+    PostPolicyError(String),
+    InvalidObjectLockConfig(String),
 }
 
 impl std::error::Error for Error {}
@@ -160,6 +162,8 @@ impl fmt::Display for Error {
 	    Error::InvalidDateAndDays(m) => write!(f, "Only one of date or days of {} must be set", m),
 	    Error::InvalidLifecycleRuleId => write!(f, "id must be exceed 255 characters"),
 	    Error::InvalidFilter => write!(f, "only one of And, Prefix or Tag must be provided"),
+	    Error::PostPolicyError(m) => write!(f, "{}", m),
+	    Error::InvalidObjectLockConfig(m) => write!(f, "{}", m),
 	}
     }
 }

src/s3/response.rs

@@ -15,7 +15,8 @@
 
 use crate::s3::error::Error;
 use crate::s3::types::{
-    parse_legal_hold, Bucket, Item, LifecycleConfig, RetentionMode, SelectProgress, SseConfig,
+    parse_legal_hold, Bucket, Item, LifecycleConfig, NotificationConfig, ObjectLockConfig,
+    ReplicationConfig, RetentionMode, SelectProgress, SseConfig,
 };
 use crate::s3::utils::{
     copy_slice, crc32, from_http_header_value, from_iso8601utc, get_text, uint32, UtcTime,
@@ -91,6 +92,8 @@ pub type CopyObjectResponse = PutObjectApiResponse;
 
 pub type ComposeObjectResponse = PutObjectApiResponse;
 
+pub type UploadObjectResponse = PutObjectApiResponse;
+
 #[derive(Debug)]
 pub struct StatObjectResponse {
     pub headers: HeaderMap,
@@ -603,6 +606,7 @@ impl SelectObjectContentResponse {
     }
 }
 
+#[derive(Clone, Debug)]
 pub struct ListenBucketNotificationResponse {
     pub headers: HeaderMap,
     pub region: String,
@@ -625,6 +629,7 @@ impl ListenBucketNotificationResponse {
 
 pub type DeleteBucketEncryptionResponse = BucketResponse;
 
+#[derive(Clone, Debug)]
 pub struct GetBucketEncryptionResponse {
     pub headers: HeaderMap,
     pub region: String,
@@ -638,6 +643,7 @@ pub type EnableObjectLegalHoldResponse = ObjectResponse;
 
 pub type DisableObjectLegalHoldResponse = ObjectResponse;
 
+#[derive(Clone, Debug)]
 pub struct IsObjectLegalHoldEnabledResponse {
     pub headers: HeaderMap,
     pub region: String,
@@ -649,6 +655,7 @@ pub struct IsObjectLegalHoldEnabledResponse {
 
 pub type DeleteBucketLifecycleResponse = BucketResponse;
 
+#[derive(Clone, Debug)]
 pub struct GetBucketLifecycleResponse {
     pub headers: HeaderMap,
     pub region: String,
@@ -657,3 +664,119 @@ pub struct GetBucketLifecycleResponse {
 }
 
 pub type SetBucketLifecycleResponse = BucketResponse;
+
+pub type DeleteBucketNotificationResponse = BucketResponse;
+
+#[derive(Clone, Debug)]
+pub struct GetBucketNotificationResponse {
+    pub headers: HeaderMap,
+    pub region: String,
+    pub bucket_name: String,
+    pub config: NotificationConfig,
+}
+
+pub type SetBucketNotificationResponse = BucketResponse;
+
+pub type DeleteBucketPolicyResponse = BucketResponse;
+
+#[derive(Clone, Debug)]
+pub struct GetBucketPolicyResponse {
+    pub headers: HeaderMap,
+    pub region: String,
+    pub bucket_name: String,
+    pub config: String,
+}
+
+pub type SetBucketPolicyResponse = BucketResponse;
+
+pub type DeleteBucketReplicationResponse = BucketResponse;
+
+#[derive(Clone, Debug)]
+pub struct GetBucketReplicationResponse {
+    pub headers: HeaderMap,
+    pub region: String,
+    pub bucket_name: String,
+    pub config: ReplicationConfig,
+}
+
+pub type SetBucketReplicationResponse = BucketResponse;
+
+pub type DeleteBucketTagsResponse = BucketResponse;
+
+#[derive(Clone, Debug)]
+pub struct GetBucketTagsResponse {
+    pub headers: HeaderMap,
+    pub region: String,
+    pub bucket_name: String,
+    pub tags: std::collections::HashMap<String, String>,
+}
+
+pub type SetBucketTagsResponse = BucketResponse;
+
+#[derive(Clone, Debug)]
+pub struct GetBucketVersioningResponse {
+    pub headers: HeaderMap,
+    pub region: String,
+    pub bucket_name: String,
+    pub status: Option<bool>,
+    pub mfa_delete: Option<bool>,
+}
+
+pub type SetBucketVersioningResponse = BucketResponse;
+
+pub type DeleteObjectLockConfigResponse = BucketResponse;
+
+#[derive(Clone, Debug)]
+pub struct GetObjectLockConfigResponse {
+    pub headers: HeaderMap,
+    pub region: String,
+    pub bucket_name: String,
+    pub config: ObjectLockConfig,
+}
+
+pub type SetObjectLockConfigResponse = BucketResponse;
+
+#[derive(Clone, Debug)]
+pub struct GetObjectRetentionResponse {
+    pub headers: HeaderMap,
+    pub region: String,
+    pub bucket_name: String,
+    pub object_name: String,
+    pub version_id: Option<String>,
+    pub retention_mode: Option<RetentionMode>,
+    pub retain_until_date: Option<UtcTime>,
+}
+
+pub type SetObjectRetentionResponse = ObjectResponse;
+
+pub type DeleteObjectTagsResponse = ObjectResponse;
+
+#[derive(Clone, Debug)]
+pub struct GetObjectTagsResponse {
+    pub headers: HeaderMap,
+    pub region: String,
+    pub bucket_name: String,
+    pub object_name: String,
+    pub version_id: Option<String>,
+    pub tags: std::collections::HashMap<String, String>,
+}
+
+pub type SetObjectTagsResponse = ObjectResponse;
+
+#[derive(Clone, Debug)]
+pub struct GetPresignedObjectUrlResponse {
+    pub region: String,
+    pub bucket_name: String,
+    pub object_name: String,
+    pub version_id: Option<String>,
+    pub url: String,
+}
+
+#[derive(Clone, Debug)]
+pub struct DownloadObjectResponse {
+    pub headers: HeaderMap,
+    pub region: String,
+    pub bucket_name: String,
+    pub object_name: String,
+    pub version_id: Option<String>,
+}

src/s3/utils.rs

@@ -262,15 +262,12 @@ pub fn get_text(element: &Element, tag: &str) -> Result<String, Error> {
         .to_string())
 }
 
-pub fn get_option_text(element: &Element, tag: &str) -> Result<Option<String>, Error> {
+pub fn get_option_text(element: &Element, tag: &str) -> Option<String> {
-    Ok(match element.get_child(tag) {
+    if let Some(v) = element.get_child(tag) {
-        Some(v) => Some(
+        return Some(v.get_text().unwrap_or_default().to_string());
-            v.get_text()
+    }
-                .ok_or(Error::XmlError(format!("text of <{}> tag not found", tag)))?
+
-                .to_string(),
+    None
-        ),
-        None => None,
-    })
 }
 
 pub fn get_default_text(element: &Element, tag: &str) -> String {

tests/start-server.sh

@@ -3,10 +3,14 @@
 set -x
 set -e
 
-wget --quiet https://dl.min.io/server/minio/release/linux-amd64/minio && \
+wget --quiet https://dl.min.io/server/minio/release/linux-amd64/minio
-    chmod +x minio && \
+chmod +x minio
-    mkdir -p /tmp/certs && \
+mkdir -p /tmp/certs
-    cp ./tests/public.crt ./tests/private.key /tmp/certs/ && \
+cp ./tests/public.crt ./tests/private.key /tmp/certs/
+
+(MINIO_CI_CD=true \
+    MINIO_NOTIFY_WEBHOOK_ENABLE_miniojavatest=on \
+    MINIO_NOTIFY_WEBHOOK_ENDPOINT_miniojavatest=http://example.org/ \
+    ./minio server /tmp/test-xl/{1...4}/ --certs-dir /tmp/certs/ &)
 
-MINIO_CI_CD=true ./minio server /tmp/test-xl/{1...4}/ --certs-dir /tmp/certs/ &
 sleep 10

tests/tests.rs

@@ -14,9 +14,14 @@
 // limitations under the License.
 
 use async_std::task;
+use chrono::Duration;
+use hyper::http::Method;
 use minio::s3::types::NotificationRecords;
 use rand::distributions::{Alphanumeric, DistString};
+use sha2::{Digest, Sha256};
+use std::collections::HashMap;
 use std::io::BufReader;
+use std::{fs, io};
 use tokio::sync::mpsc;
 
 use minio::s3::args::*;
@@ -24,9 +29,11 @@ use minio::s3::client::Client;
 use minio::s3::creds::StaticProvider;
 use minio::s3::http::BaseUrl;
 use minio::s3::types::{
-    CsvInputSerialization, CsvOutputSerialization, DeleteObject, FileHeaderInfo, QuoteFields,
+    CsvInputSerialization, CsvOutputSerialization, DeleteObject, FileHeaderInfo,
-    SelectRequest,
+    NotificationConfig, ObjectLockConfig, PrefixFilterRule, QueueConfig, QuoteFields,
+    RetentionMode, SelectRequest, SuffixFilterRule,
 };
+use minio::s3::utils::{to_iso8601utc, utc_now};
 
 struct RandReader {
     size: usize,
@@ -77,6 +84,8 @@ struct ClientTest<'a> {
 }
 
 impl<'a> ClientTest<'_> {
+    const SQS_ARN: &str = "arn:minio:sqs::miniojavatest:webhook";
+
     fn new(
         base_url: BaseUrl,
         access_key: String,
@@ -255,6 +264,89 @@ impl<'a> ClientTest<'_> {
             .unwrap();
     }
 
+    fn get_hash(filename: &String) -> String {
+        let mut hasher = Sha256::new();
+        let mut file = fs::File::open(filename).unwrap();
+        io::copy(&mut file, &mut hasher).unwrap();
+        return format!("{:x}", hasher.finalize());
+    }
+
+    async fn upload_download_object(&self) {
+        let object_name = rand_object_name();
+        let size = 16_usize;
+        let mut file = fs::File::create(&object_name).unwrap();
+        io::copy(&mut RandReader::new(size), &mut file).unwrap();
+        file.sync_all().unwrap();
+        self.client
+            .upload_object(
+                &mut UploadObjectArgs::new(&self.test_bucket, &object_name, &object_name).unwrap(),
+            )
+            .await
+            .unwrap();
+
+        let filename = rand_object_name();
+        self.client
+            .download_object(
+                &DownloadObjectArgs::new(&self.test_bucket, &object_name, &filename).unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(
+            ClientTest::get_hash(&object_name) == ClientTest::get_hash(&filename),
+            true
+        );
+
+        fs::remove_file(&object_name).unwrap();
+        fs::remove_file(&filename).unwrap();
+
+        self.client
+            .remove_object(&RemoveObjectArgs::new(&self.test_bucket, &object_name).unwrap())
+            .await
+            .unwrap();
+
+        self.client
+            .remove_object(&RemoveObjectArgs::new(&self.test_bucket, &object_name).unwrap())
+            .await
+            .unwrap();
+
+        let object_name = rand_object_name();
+        let size: usize = 16 + 5 * 1024 * 1024;
+        let mut file = fs::File::create(&object_name).unwrap();
+        io::copy(&mut RandReader::new(size), &mut file).unwrap();
+        file.sync_all().unwrap();
+        self.client
+            .upload_object(
+                &mut UploadObjectArgs::new(&self.test_bucket, &object_name, &object_name).unwrap(),
+            )
+            .await
+            .unwrap();
+
+        let filename = rand_object_name();
+        self.client
+            .download_object(
+                &DownloadObjectArgs::new(&self.test_bucket, &object_name, &filename).unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(
+            ClientTest::get_hash(&object_name) == ClientTest::get_hash(&filename),
+            true
+        );
+
+        fs::remove_file(&object_name).unwrap();
+        fs::remove_file(&filename).unwrap();
+
+        self.client
+            .remove_object(&RemoveObjectArgs::new(&self.test_bucket, &object_name).unwrap())
+            .await
+            .unwrap();
+
+        self.client
+            .remove_object(&RemoveObjectArgs::new(&self.test_bucket, &object_name).unwrap())
+            .await
+            .unwrap();
+    }
+
     async fn remove_objects(&self) {
         let bucket_name = rand_bucket_name();
         self.client
@@ -598,6 +690,479 @@ impl<'a> ClientTest<'_> {
             .await
             .unwrap();
     }
+
+    async fn set_get_delete_bucket_notification(&self) {
+        let bucket_name = rand_bucket_name();
+        self.client
+            .make_bucket(&MakeBucketArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+
+        self.client
+            .set_bucket_notification(
+                &SetBucketNotificationArgs::new(
+                    &bucket_name,
+                    &NotificationConfig {
+                        cloud_func_config_list: None,
+                        queue_config_list: Some(vec![QueueConfig {
+                            events: vec![
+                                String::from("s3:ObjectCreated:Put"),
+                                String::from("s3:ObjectCreated:Copy"),
+                            ],
+                            id: None,
+                            prefix_filter_rule: Some(PrefixFilterRule {
+                                value: String::from("images"),
+                            }),
+                            suffix_filter_rule: Some(SuffixFilterRule {
+                                value: String::from("pg"),
+                            }),
+                            queue: String::from(ClientTest::SQS_ARN),
+                        }]),
+                        topic_config_list: None,
+                    },
+                )
+                .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        let resp = self
+            .client
+            .get_bucket_notification(&GetBucketNotificationArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(resp.config.queue_config_list.as_ref().unwrap().len(), 1);
+        assert_eq!(
+            resp.config.queue_config_list.as_ref().unwrap()[0]
+                .events
+                .contains(&String::from("s3:ObjectCreated:Put")),
+            true
+        );
+        assert_eq!(
+            resp.config.queue_config_list.as_ref().unwrap()[0]
+                .events
+                .contains(&String::from("s3:ObjectCreated:Copy")),
+            true
+        );
+        assert_eq!(
+            resp.config.queue_config_list.as_ref().unwrap()[0]
+                .prefix_filter_rule
+                .as_ref()
+                .unwrap()
+                .value,
+            "images"
+        );
+        assert_eq!(
+            resp.config.queue_config_list.as_ref().unwrap()[0]
+                .suffix_filter_rule
+                .as_ref()
+                .unwrap()
+                .value,
+            "pg"
+        );
+        assert_eq!(
+            resp.config.queue_config_list.as_ref().unwrap()[0].queue,
+            ClientTest::SQS_ARN
+        );
+
+        self.client
+            .delete_bucket_notification(&DeleteBucketNotificationArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+
+        let resp = self
+            .client
+            .get_bucket_notification(&GetBucketNotificationArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(resp.config.queue_config_list.is_none(), true);
+
+        self.client
+            .remove_bucket(&RemoveBucketArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+    }
+
+    async fn set_get_delete_bucket_policy(&self) {
+        let bucket_name = rand_bucket_name();
+        self.client
+            .make_bucket(&MakeBucketArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+
+        let config = r#"
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Action": [
+                "s3:GetObject"
+            ],
+            "Effect": "Allow",
+            "Principal": {
+                "AWS": [
+                    "*"
+                ]
+            },
+            "Resource": [
+                "arn:aws:s3:::<BUCKET>/myobject*"
+            ],
+            "Sid": ""
+        }
+    ]
+}
+"#
+        .replace("<BUCKET>", &bucket_name);
+
+        self.client
+            .set_bucket_policy(&SetBucketPolicyArgs::new(&bucket_name, &config).unwrap())
+            .await
+            .unwrap();
+
+        let resp = self
+            .client
+            .get_bucket_policy(&GetBucketPolicyArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(resp.config.is_empty(), false);
+
+        self.client
+            .delete_bucket_policy(&DeleteBucketPolicyArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+
+        let resp = self
+            .client
+            .get_bucket_policy(&GetBucketPolicyArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(resp.config, "{}");
+
+        self.client
+            .remove_bucket(&RemoveBucketArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+    }
+
+    async fn set_get_delete_bucket_tags(&self) {
+        let bucket_name = rand_bucket_name();
+        self.client
+            .make_bucket(&MakeBucketArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+
+        let tags = HashMap::from([
+            (String::from("Project"), String::from("Project One")),
+            (String::from("User"), String::from("jsmith")),
+        ]);
+
+        self.client
+            .set_bucket_tags(&SetBucketTagsArgs::new(&bucket_name, &tags).unwrap())
+            .await
+            .unwrap();
+
+        let resp = self
+            .client
+            .get_bucket_tags(&GetBucketTagsArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(
+            resp.tags.len() == tags.len() && resp.tags.keys().all(|k| tags.contains_key(k)),
+            true
+        );
+
+        self.client
+            .delete_bucket_tags(&DeleteBucketTagsArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+
+        let resp = self
+            .client
+            .get_bucket_tags(&GetBucketTagsArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(resp.tags.is_empty(), true);
+
+        self.client
+            .remove_bucket(&RemoveBucketArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+    }
+
+    async fn set_get_delete_object_lock_config(&self) {
+        let bucket_name = rand_bucket_name();
+
+        let mut args = MakeBucketArgs::new(&bucket_name).unwrap();
+        args.object_lock = true;
+        self.client.make_bucket(&args).await.unwrap();
+
+        self.client
+            .set_object_lock_config(
+                &SetObjectLockConfigArgs::new(
+                    &bucket_name,
+                    &ObjectLockConfig::new(RetentionMode::GOVERNANCE, Some(7), None).unwrap(),
+                )
+                .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        let resp = self
+            .client
+            .get_object_lock_config(&GetObjectLockConfigArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(
+            match resp.config.retention_mode {
+                Some(r) => match r {
+                    RetentionMode::GOVERNANCE => true,
+                    _ => false,
+                },
+                _ => false,
+            },
+            true
+        );
+
+        assert_eq!(resp.config.retention_duration_days == Some(7), true);
+        assert_eq!(resp.config.retention_duration_years.is_none(), true);
+
+        self.client
+            .delete_object_lock_config(&DeleteObjectLockConfigArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+
+        let resp = self
+            .client
+            .get_object_lock_config(&GetObjectLockConfigArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(resp.config.retention_mode.is_none(), true);
+
+        self.client
+            .remove_bucket(&RemoveBucketArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+    }
+
+    async fn set_get_delete_object_tags(&self) {
+        let object_name = rand_object_name();
+
+        let size = 16_usize;
+        self.client
+            .put_object(
+                &mut PutObjectArgs::new(
+                    &self.test_bucket,
+                    &object_name,
+                    &mut RandReader::new(size),
+                    Some(size),
+                    None,
+                )
+                .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        let tags = HashMap::from([
+            (String::from("Project"), String::from("Project One")),
+            (String::from("User"), String::from("jsmith")),
+        ]);
+
+        self.client
+            .set_object_tags(
+                &SetObjectTagsArgs::new(&self.test_bucket, &object_name, &tags).unwrap(),
+            )
+            .await
+            .unwrap();
+
+        let resp = self
+            .client
+            .get_object_tags(&GetObjectTagsArgs::new(&self.test_bucket, &object_name).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(
+            resp.tags.len() == tags.len() && resp.tags.keys().all(|k| tags.contains_key(k)),
+            true
+        );
+
+        self.client
+            .delete_object_tags(
+                &DeleteObjectTagsArgs::new(&self.test_bucket, &object_name).unwrap(),
+            )
+            .await
+            .unwrap();
+
+        let resp = self
+            .client
+            .get_object_tags(&GetObjectTagsArgs::new(&self.test_bucket, &object_name).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(resp.tags.is_empty(), true);
+
+        self.client
+            .remove_object(&RemoveObjectArgs::new(&self.test_bucket, &object_name).unwrap())
+            .await
+            .unwrap();
+    }
+
+    async fn set_get_bucket_versioning(&self) {
+        let bucket_name = rand_bucket_name();
+
+        self.client
+            .make_bucket(&MakeBucketArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+
+        self.client
+            .set_bucket_versioning(&SetBucketVersioningArgs::new(&bucket_name, true).unwrap())
+            .await
+            .unwrap();
+
+        let resp = self
+            .client
+            .get_bucket_versioning(&GetBucketVersioningArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(
+            match resp.status {
+                Some(v) => v,
+                _ => false,
+            },
+            true
+        );
+
+        self.client
+            .set_bucket_versioning(&SetBucketVersioningArgs::new(&bucket_name, false).unwrap())
+            .await
+            .unwrap();
+
+        let resp = self
+            .client
+            .get_bucket_versioning(&GetBucketVersioningArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(
+            match resp.status {
+                Some(v) => v,
+                _ => false,
+            },
+            false
+        );
+
+        self.client
+            .remove_bucket(&RemoveBucketArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+    }
+
+    async fn set_get_object_retention(&self) {
+        let bucket_name = rand_bucket_name();
+
+        let mut args = MakeBucketArgs::new(&bucket_name).unwrap();
+        args.object_lock = true;
+        self.client.make_bucket(&args).await.unwrap();
+
+        let object_name = rand_object_name();
+
+        let size = 16_usize;
+        let obj_resp = self
+            .client
+            .put_object(
+                &mut PutObjectArgs::new(
+                    &bucket_name,
+                    &object_name,
+                    &mut RandReader::new(size),
+                    Some(size),
+                    None,
+                )
+                .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        let mut args = SetObjectRetentionArgs::new(&bucket_name, &object_name).unwrap();
+        args.retention_mode = Some(RetentionMode::GOVERNANCE);
+        let retain_until_date = utc_now() + Duration::days(1);
+        args.retain_until_date = Some(retain_until_date);
+
+        self.client.set_object_retention(&args).await.unwrap();
+
+        let resp = self
+            .client
+            .get_object_retention(&GetObjectRetentionArgs::new(&bucket_name, &object_name).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(
+            match resp.retention_mode {
+                Some(v) => match v {
+                    RetentionMode::GOVERNANCE => true,
+                    _ => false,
+                },
+                _ => false,
+            },
+            true
+        );
+        assert_eq!(
+            match resp.retain_until_date {
+                Some(v) => to_iso8601utc(v) == to_iso8601utc(retain_until_date),
+                _ => false,
+            },
+            true,
+        );
+
+        let mut args = SetObjectRetentionArgs::new(&bucket_name, &object_name).unwrap();
+        args.bypass_governance_mode = true;
+        self.client.set_object_retention(&args).await.unwrap();
+
+        let resp = self
+            .client
+            .get_object_retention(&GetObjectRetentionArgs::new(&bucket_name, &object_name).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(resp.retention_mode.is_none(), true);
+        assert_eq!(resp.retain_until_date.is_none(), true);
+
+        let mut args = RemoveObjectArgs::new(&bucket_name, &object_name).unwrap();
+        let version_id = obj_resp.version_id.unwrap().clone();
+        args.version_id = Some(version_id.as_str());
+        self.client.remove_object(&args).await.unwrap();
+
+        self.client
+            .remove_bucket(&RemoveBucketArgs::new(&bucket_name).unwrap())
+            .await
+            .unwrap();
+    }
+
+    async fn get_presigned_object_url(&self) {
+        let object_name = rand_object_name();
+        let resp = self
+            .client
+            .get_presigned_object_url(
+                &GetPresignedObjectUrlArgs::new(&self.test_bucket, &object_name, Method::GET)
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(resp.url.contains("X-Amz-Signature="), true);
+    }
+
+    async fn get_presigned_post_form_data(&self) {
+        let object_name = rand_object_name();
+        let expiration = utc_now() + Duration::days(5);
+
+        let mut policy = PostPolicy::new(&self.test_bucket, &expiration).unwrap();
+        policy.add_equals_condition("key", &object_name).unwrap();
+        policy
+            .add_content_length_range_condition(1 * 1024 * 1024, 4 * 1024 * 1024)
+            .unwrap();
+
+        let form_data = self
+            .client
+            .get_presigned_post_form_data(&policy)
+            .await
+            .unwrap();
+        assert_eq!(form_data.contains_key("x-amz-signature"), true);
+        assert_eq!(form_data.contains_key("policy"), true);
+    }
 }
 
 #[tokio::main]
@@ -628,9 +1193,6 @@ async fn s3_tests() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     );
     ctest.init().await;
 
-    println!("compose_object()");
-    ctest.compose_object().await;
-
     println!("make_bucket() + bucket_exists() + remove_bucket()");
     ctest.bucket_exists().await;
 
@@ -646,6 +1208,9 @@ async fn s3_tests() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     println!("get_object()");
     ctest.get_object().await;
 
+    println!("{{upload,download}}_object()");
+    ctest.upload_download_object().await;
+
     println!("remove_objects()");
     ctest.remove_objects().await;
 
@@ -661,6 +1226,36 @@ async fn s3_tests() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     println!("copy_object()");
     ctest.copy_object().await;
 
+    println!("compose_object()");
+    ctest.compose_object().await;
+
+    println!("{{set,get,delete}}_bucket_notification()");
+    ctest.set_get_delete_bucket_notification().await;
+
+    println!("{{set,get,delete}}_bucket_policy()");
+    ctest.set_get_delete_bucket_policy().await;
+
+    println!("{{set,get,delete}}_bucket_tags()");
+    ctest.set_get_delete_bucket_tags().await;
+
+    println!("{{set,get,delete}}_object_lock_config()");
+    ctest.set_get_delete_object_lock_config().await;
+
+    println!("{{set,get,delete}}_object_tags()");
+    ctest.set_get_delete_object_tags().await;
+
+    println!("{{set,get}}_bucket_versioning()");
+    ctest.set_get_bucket_versioning().await;
+
+    println!("{{set,get}}_object_retention()");
+    ctest.set_get_object_retention().await;
+
+    println!("get_presigned_object_url()");
+    ctest.get_presigned_object_url().await;
+
+    println!("get_presigned_post_form_data()");
+    ctest.get_presigned_post_form_data().await;
+
     ctest.drop().await;
 
     Ok(())