trust-registry 0.20.0

Trust Registry
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

#[cfg(feature = "loaders-aws")]
pub mod aws_parameter_store;
#[cfg(feature = "loaders-aws")]
pub mod aws_secrets;
pub mod environment;
pub mod file;
pub mod string;

/// Resolve a config value from a loader URI.
///
/// `string://` and `file://` are dependency-free and always available. The AWS
/// schemes are behind `loaders-aws`; when that feature is off they are rejected
/// by name rather than silently falling through to `string::load`, which would
/// hand the caller the literal URI as if it were the secret.
pub async fn load(input: &str) -> Result<String, String> {
    if let Some(content) = input.strip_prefix("string://") {
        string::load(content)
    } else if let Some(path) = input.strip_prefix("file://") {
        file::load(path)
    } else if let Some(_secret_name) = input.strip_prefix("aws_secrets://") {
        #[cfg(feature = "loaders-aws")]
        {
            aws_secrets::load(_secret_name).await
        }
        #[cfg(not(feature = "loaders-aws"))]
        Err("aws_secrets:// requires the `loaders-aws` feature, which is not compiled in".into())
    } else if let Some(_param_name) = input.strip_prefix("aws_parameter_store://") {
        #[cfg(feature = "loaders-aws")]
        {
            aws_parameter_store::load(_param_name).await
        }
        #[cfg(not(feature = "loaders-aws"))]
        Err(
            "aws_parameter_store:// requires the `loaders-aws` feature, which is not compiled in"
                .into(),
        )
    } else {
        string::load(input)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;
    use tempfile::NamedTempFile;

    #[tokio::test]
    async fn test_load_string_uri() {
        let result = load("string://test content").await.unwrap();
        assert_eq!(result, "test content");
    }

    #[tokio::test]
    async fn test_load_string_uri_json() {
        let json = r#"{"key":"value"}"#;
        let result = load(&format!("string://{}", json)).await.unwrap();
        assert_eq!(result, json);
    }

    #[tokio::test]
    async fn test_load_file_uri() {
        let temp_file = NamedTempFile::new().unwrap();
        fs::write(&temp_file, "file content").unwrap();

        let uri = format!("file://{}", temp_file.path().to_str().unwrap());
        let result = load(&uri).await.unwrap();
        assert_eq!(result, "file content");
    }

    #[tokio::test]
    async fn test_load_invalid_uri_scheme() {
        let result = load("invalid://test").await;
        assert!(result.is_ok());
        assert!(result.unwrap().contains("invalid://test"));
    }

    #[tokio::test]
    async fn test_load_no_scheme() {
        let result = load("just-a-string").await;
        assert!(result.is_ok());
        assert!(result.unwrap().contains("just-a-string"));
    }
}