hive-router 0.2.0

GraphQL router for Federation, part of the Hive platform
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

use crate::config::response_extensions::{ExtensionsMergeAlgo, ResponseExtensionsConfig};
use ahash::HashSet;

use super::plan::{ExtensionsMergeStrategy, ExtensionsPlan, ExtensionsPropagatePlan};

pub fn compile_extensions_plan(cfg: &ResponseExtensionsConfig) -> ExtensionsPlan {
    let propagate = cfg.propagate.as_ref().map(|p| ExtensionsPropagatePlan {
        strategy: match p.algorithm {
            ExtensionsMergeAlgo::First => ExtensionsMergeStrategy::First,
            ExtensionsMergeAlgo::Last => ExtensionsMergeStrategy::Last,
            ExtensionsMergeAlgo::Append => ExtensionsMergeStrategy::Append,
        },
        allow: p
            .allow
            .as_ref()
            .map(|keys| keys.iter().cloned().collect::<HashSet<String>>()),
    });

    ExtensionsPlan { propagate }
}

#[cfg(test)]
mod tests {
    use crate::config::response_extensions::{
        ExtensionsMergeAlgo, ExtensionsPropagateConfig, ResponseExtensionsConfig,
    };

    use super::*;
    use crate::executor::extensions::plan::ExtensionsMergeStrategy;

    #[test]
    fn test_compile_last() {
        let cfg = ResponseExtensionsConfig {
            propagate: Some(ExtensionsPropagateConfig {
                algorithm: ExtensionsMergeAlgo::Last,
                allow: None,
            }),
        };
        let plan = compile_extensions_plan(&cfg);
        let p = plan.propagate.unwrap();
        assert!(matches!(p.strategy, ExtensionsMergeStrategy::Last));
        assert!(p.allow.is_none());
    }

    #[test]
    fn test_compile_first() {
        let cfg = ResponseExtensionsConfig {
            propagate: Some(ExtensionsPropagateConfig {
                algorithm: ExtensionsMergeAlgo::First,
                allow: None,
            }),
        };
        let plan = compile_extensions_plan(&cfg);
        assert!(matches!(
            plan.propagate.unwrap().strategy,
            ExtensionsMergeStrategy::First
        ));
    }

    #[test]
    fn test_compile_append() {
        let cfg = ResponseExtensionsConfig {
            propagate: Some(ExtensionsPropagateConfig {
                algorithm: ExtensionsMergeAlgo::Append,
                allow: None,
            }),
        };
        let plan = compile_extensions_plan(&cfg);
        assert!(matches!(
            plan.propagate.unwrap().strategy,
            ExtensionsMergeStrategy::Append
        ));
    }

    #[test]
    fn test_compile_allow_list() {
        let cfg = ResponseExtensionsConfig {
            propagate: Some(ExtensionsPropagateConfig {
                algorithm: ExtensionsMergeAlgo::Last,
                allow: Some(vec!["foo".to_string(), "bar".to_string()]),
            }),
        };
        let plan = compile_extensions_plan(&cfg);
        let allow = plan.propagate.unwrap().allow.unwrap();
        assert!(allow.contains("foo"));
        assert!(allow.contains("bar"));
        assert!(!allow.contains("baz"));
        assert_eq!(allow.len(), 2);
    }

    #[test]
    fn test_compile_no_propagate() {
        let cfg = ResponseExtensionsConfig { propagate: None };
        let plan = compile_extensions_plan(&cfg);
        assert!(plan.propagate.is_none());
    }
}