rc-core 0.1.21

Core library for rustfs-cli S3 CLI client
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

//! Bucket and object encryption domain types.

use serde::{Deserialize, Serialize};

/// Bucket default encryption configuration.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum BucketEncryption {
    /// Use S3-managed keys.
    SseS3,
    /// Use KMS-managed keys with an optional explicit key id.
    SseKms {
        #[serde(skip_serializing_if = "Option::is_none")]
        key_id: Option<String>,
    },
}

/// Object write encryption request.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum ObjectEncryptionRequest {
    /// Use S3-managed keys.
    SseS3,
    /// Use KMS-managed keys with the provided key id.
    SseKms { key_id: String },
}

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

    #[test]
    fn bucket_encryption_serializes_sse_s3() {
        let json = serde_json::to_value(&BucketEncryption::SseS3).expect("serialize sse-s3");
        assert_eq!(json, json!("sse-s3"));
    }

    #[test]
    fn bucket_encryption_serializes_sse_kms_key_id() {
        let json = serde_json::to_value(&BucketEncryption::SseKms {
            key_id: Some("kms-key".to_string()),
        })
        .expect("serialize sse-kms");
        assert_eq!(json, json!({ "sse-kms": { "key_id": "kms-key" } }));
    }

    #[test]
    fn bucket_encryption_serializes_sse_kms_without_key_id() {
        let json = serde_json::to_value(&BucketEncryption::SseKms { key_id: None })
            .expect("serialize sse-kms without key");
        assert_eq!(json, json!({ "sse-kms": {} }));
    }

    #[test]
    fn bucket_encryption_round_trips_sse_s3() {
        let value: BucketEncryption =
            serde_json::from_value(json!("sse-s3")).expect("deserialize sse-s3");
        assert_eq!(value, BucketEncryption::SseS3);
    }

    #[test]
    fn bucket_encryption_round_trips_sse_kms() {
        let value: BucketEncryption =
            serde_json::from_value(json!({ "sse-kms": { "key_id": "kms-key" } }))
                .expect("deserialize sse-kms");
        assert_eq!(
            value,
            BucketEncryption::SseKms {
                key_id: Some("kms-key".to_string()),
            }
        );
    }

    #[test]
    fn bucket_encryption_round_trips_sse_kms_without_key_id() {
        let value: BucketEncryption = serde_json::from_value(json!({ "sse-kms": {} }))
            .expect("deserialize sse-kms without key");
        assert_eq!(value, BucketEncryption::SseKms { key_id: None });
    }

    #[test]
    fn object_encryption_request_serializes_sse_s3() {
        let json =
            serde_json::to_value(&ObjectEncryptionRequest::SseS3).expect("serialize object sse-s3");
        assert_eq!(json, json!("sse-s3"));
    }

    #[test]
    fn object_encryption_request_serializes_sse_kms() {
        let json = serde_json::to_value(&ObjectEncryptionRequest::SseKms {
            key_id: "kms-key".to_string(),
        })
        .expect("serialize object sse-kms");
        assert_eq!(json, json!({ "sse-kms": { "key_id": "kms-key" } }));
    }

    #[test]
    fn object_encryption_request_round_trips_sse_s3() {
        let value: ObjectEncryptionRequest =
            serde_json::from_value(json!("sse-s3")).expect("deserialize object sse-s3");
        assert_eq!(value, ObjectEncryptionRequest::SseS3);
    }

    #[test]
    fn object_encryption_request_round_trips_sse_kms() {
        let value: ObjectEncryptionRequest =
            serde_json::from_value(json!({ "sse-kms": { "key_id": "kms-key" } }))
                .expect("deserialize object sse-kms");
        assert_eq!(
            value,
            ObjectEncryptionRequest::SseKms {
                key_id: "kms-key".to_string(),
            }
        );
    }
}