compose-validatr 0.1.3

Library for parsing and validating Docker compose manifests
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

use serde::{Deserialize, Serialize};

use crate::compose::{Compose, Validate};

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum Secret {
    Short(String),
    Long(SecretOptions),
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SecretOptions {
    pub source: String,
    pub target: String,
    pub uid: String,
    pub gid: String,
    pub mode: String,
}

impl Validate for Secret {
    fn validate(&self, ctx: &Compose, errors: &mut crate::errors::ValidationErrors) {
        match self {
            Secret::Short(s) => {
                ctx.secrets.as_ref().map(|available_secrets| {
                    if !available_secrets.contains_key(s) {
                        errors.add_error(crate::errors::ValidationError::InvalidValue(format!(
                            "Service secrets reference an unknown secret: {s}"
                        )));
                    }
                });
            }
            Secret::Long(s) => {
                ctx.secrets.as_ref().map(|available_secrets| {
                    if !available_secrets.contains_key(s.source.as_str()) {
                        errors.add_error(crate::errors::ValidationError::InvalidValue(format!(
                            "Service secrets reference an unknown secret: {}",
                            s.source
                        )));
                    }
                });
            }
        }
    }
}

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

    #[test]
    fn missing_secret() {
        let yaml = r#"
        services:
          frontend:
            image: example/webapp
            secrets:
              - server-certificate
        secrets:
          helloworld:
            file: ./server.cert
          worldhello:
            file: ./server.cert
        "#;
        let compose = Compose::new(yaml);
        assert!(compose.is_err());
    }

    #[test]
    fn valid_secret() {
        let yaml = r#"
        services:
          frontend:
            image: example/webapp
            secrets:
              - helloworld
        secrets:
          helloworld:
            file: ./server.cert
        "#;
        let compose = Compose::new(yaml);
        assert!(compose.is_ok());
    }
}