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
85
86
87
88
89
90
91
92
93
94
95
96

use std::collections::HashMap;

use serde::{Deserialize, Serialize};

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

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum Networks {
    List(Vec<String>),
    Map(HashMap<String, NetworkOptions>),
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct NetworkOptions {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub aliases: Option<Vec<String>>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub ipv4_address: Option<String>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub ipv6_address: Option<String>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub link_local_ips: Option<Vec<String>>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub priority: Option<u16>,
}

impl Validate for Networks {
    fn validate(&self, ctx: &Compose, errors: &mut crate::errors::ValidationErrors) {
        match self {
            Networks::List(n) => {
                ctx.networks.as_ref().map(|available_networks| {
                    n.iter().for_each(|network| {
                        if !available_networks.contains_key(network) {
                            errors.add_error(crate::errors::ValidationError::InvalidValue(
                                format!("Service networks reference an unknown network: {network}"),
                            ));
                        }
                    });
                });
            }
            Networks::Map(n) => {
                ctx.networks.as_ref().map(|available_networks| {
                    n.keys().for_each(|network| {
                        if !available_networks.contains_key(network) {
                            errors.add_error(crate::errors::ValidationError::InvalidValue(
                                format!("Service networks reference an unknown network: {network}"),
                            ));
                        }
                    });
                });
            }
        }
    }
}

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

    #[test]
    fn invalid_network() {
        let yaml = r#"
        services:
          some-service:
            networks:
              - hello
              - world
        networks:
            some-network:
            other-network:
        "#;
        let compose = Compose::new(yaml);
        assert!(compose.is_err());
    }

    #[test]
    fn valid_network() {
        let yaml = r#"
        services:
          some-service:
            networks:
              - some-network
              - other-network
        networks:
            some-network:
            other-network:
        "#;
        let compose = Compose::new(yaml);
        assert!(compose.is_ok());
    }
}