rops 0.1.7

SOPS-like library in pure Rust
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

use std::str::FromStr;

use derive_more::Display;

use crate::*;

#[derive(Debug, PartialEq, Display)]
#[display("{}.{}.{}", profile, id, secret)]
pub struct AwsPrivateKey {
    pub(super) profile: String,
    pub(super) id: String,
    pub(super) secret: String,
}

impl FromStr for AwsPrivateKey {
    type Err = IntegrationError;

    fn from_str(str: &str) -> Result<Self, Self::Err> {
        const PROFILE_COMPONENT: &str = "profile";
        const ID_COMPONENT: &str = "aws_access_key_id";
        const SECRET_COMPONENT: &str = "aws_secret_access_key";

        let mut key_components = str.split('.');

        let mut next_component = |component_name: &str| -> IntegrationResult<String> {
            key_components
                .next()
                .ok_or(IntegrationError::PrivateKeyParsing(anyhow::anyhow!(
                    "invalid private key syntax, missing the {} component in: '{}.{}.{}', got: '{}'",
                    component_name,
                    PROFILE_COMPONENT,
                    ID_COMPONENT,
                    SECRET_COMPONENT,
                    str
                )))
                .map(ToString::to_string)
        };

        // IMPROVEMENT: assert length of iterator is 3.

        Ok(Self {
            profile: next_component(PROFILE_COMPONENT)?,
            id: next_component(ID_COMPONENT)?,
            secret: next_component(SECRET_COMPONENT)?,
        })
    }
}

#[cfg(feature = "test-utils")]
mod mock {
    use super::*;

    // TODO(XXX): Access key to a rops dummy account with the singular permission of using the mock AWS
    // KMS key. Use #[ignore] and read secret from env with new account before release?

    impl MockDisplayTestUtil for AwsPrivateKey {
        fn mock_display() -> String {
            "default.AKIA3647SRLJ3HRB32X2.BRZLmZxLHH3A2OSBiUHHJ3iX7mI5Astd2ZDIkigu".to_string()
        }
    }

    impl MockTestUtil for AwsPrivateKey {
        fn mock() -> Self {
            Self {
                profile: "default".to_string(),
                id: "AKIA3647SRLJ3HRB32X2".to_string(),
                secret: "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".to_string(),
            }
        }
    }
}

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

    #[test]
    fn parses_private_key() {
        FromStrTestUtils::assert_parse::<AwsPrivateKey>()
    }

    #[test]
    fn displays_private_key() {
        DisplayTestUtils::assert_display::<AwsPrivateKey>()
    }
}