hardware-enclave 0.1.4

Hardware-backed key management — macOS Secure Enclave, Windows TPM 2.0, Linux TPM/keyring — plus in-process memory protection
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

#![allow(dead_code, unused_imports, unused_qualifications, unreachable_patterns)]
#![cfg_attr(test, allow(clippy::panic))]

use super::types::IntegrationType;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ConfigOverride {
    None,
    EnvironmentVariable { name: String },
    CommandLineFlag { flag: String },
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AppSpec {
    pub display_name: String,
    pub executable_name: String,
    /// Which integration types this application supports, in order of preference.
    /// The adapter will select the first type that matches an available payload.
    pub supported_integrations: Vec<IntegrationType>,
    pub config_override: ConfigOverride,
}

impl AppSpec {
    pub fn supports(&self, integration: IntegrationType) -> bool {
        self.supported_integrations.contains(&integration)
    }
}

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

    fn spec_with(types: Vec<IntegrationType>) -> AppSpec {
        AppSpec {
            display_name: "test-app".into(),
            executable_name: "test-app".into(),
            supported_integrations: types,
            config_override: ConfigOverride::None,
        }
    }

    #[test]
    fn supports_returns_true_when_integration_is_in_list() {
        let spec = spec_with(vec![
            IntegrationType::HelperTool,
            IntegrationType::EnvInterpolation,
        ]);
        assert!(spec.supports(IntegrationType::HelperTool));
        assert!(spec.supports(IntegrationType::EnvInterpolation));
    }

    #[test]
    fn supports_returns_false_when_integration_is_not_in_list() {
        let spec = spec_with(vec![IntegrationType::HelperTool]);
        assert!(!spec.supports(IntegrationType::EnvInterpolation));
        assert!(!spec.supports(IntegrationType::TempMaterializedConfig));
    }

    #[test]
    fn supports_returns_false_for_empty_supported_list() {
        let spec = spec_with(Vec::new());
        assert!(!spec.supports(IntegrationType::HelperTool));
        assert!(!spec.supports(IntegrationType::EnvInterpolation));
        assert!(!spec.supports(IntegrationType::TempMaterializedConfig));
    }

    #[test]
    fn config_override_none_variant_equality() {
        assert_eq!(ConfigOverride::None, ConfigOverride::None);
    }

    #[test]
    fn config_override_environment_variable_stores_name() {
        let co = ConfigOverride::EnvironmentVariable {
            name: "MY_TOKEN".into(),
        };
        if let ConfigOverride::EnvironmentVariable { name } = co {
            assert_eq!(name, "MY_TOKEN");
        } else {
            panic!("expected EnvironmentVariable variant");
        }
    }

    #[test]
    fn config_override_command_line_flag_stores_flag() {
        let co = ConfigOverride::CommandLineFlag {
            flag: "--config".into(),
        };
        if let ConfigOverride::CommandLineFlag { flag } = co {
            assert_eq!(flag, "--config");
        } else {
            panic!("expected CommandLineFlag variant");
        }
    }

    #[test]
    fn config_override_different_variants_are_not_equal() {
        let env_var = ConfigOverride::EnvironmentVariable { name: "X".into() };
        let cli_flag = ConfigOverride::CommandLineFlag { flag: "--x".into() };
        assert_ne!(env_var, ConfigOverride::None);
        assert_ne!(cli_flag, ConfigOverride::None);
        assert_ne!(env_var, cli_flag);
    }

    #[test]
    fn app_spec_clone_is_equal() {
        let spec = AppSpec {
            display_name: "My App".into(),
            executable_name: "myapp".into(),
            supported_integrations: vec![IntegrationType::EnvInterpolation],
            config_override: ConfigOverride::CommandLineFlag {
                flag: "--token".into(),
            },
        };
        let cloned = spec.clone();
        assert_eq!(spec.display_name, cloned.display_name);
        assert_eq!(spec.executable_name, cloned.executable_name);
        assert_eq!(spec.supported_integrations, cloned.supported_integrations);
        assert_eq!(spec.config_override, cloned.config_override);
    }

    #[test]
    fn supports_all_three_integration_types_when_all_listed() {
        let spec = spec_with(vec![
            IntegrationType::HelperTool,
            IntegrationType::EnvInterpolation,
            IntegrationType::TempMaterializedConfig,
        ]);
        assert!(spec.supports(IntegrationType::HelperTool));
        assert!(spec.supports(IntegrationType::EnvInterpolation));
        assert!(spec.supports(IntegrationType::TempMaterializedConfig));
    }

    #[test]
    fn supports_temp_materialized_config_only() {
        let spec = spec_with(vec![IntegrationType::TempMaterializedConfig]);
        assert!(spec.supports(IntegrationType::TempMaterializedConfig));
        assert!(!spec.supports(IntegrationType::HelperTool));
        assert!(!spec.supports(IntegrationType::EnvInterpolation));
    }
}