Skip to main content

esh_providers_azure/
lib.rs

1//! Azure Key Vault secrets provider with injectable client.
2
3use async_trait::async_trait;
4use esh_core::{
5    ConfigValue, Error, Provider, ProviderCapability, ProviderId, ProviderMeta, Result,
6};
7use std::collections::HashMap;
8use std::sync::Arc;
9
10/// Client abstraction for Key Vault secret get.
11#[async_trait]
12pub trait AzureKeyVaultClient: Send + Sync {
13    /// Fetch secret by name.
14    async fn get_secret(&self, name: &str) -> Result<String>;
15}
16
17/// In-memory fake client.
18#[derive(Default, Clone)]
19pub struct MapAzureClient {
20    secrets: HashMap<String, String>,
21    fault: Option<AzureFault>,
22}
23
24/// Injected failure mode for [`MapAzureClient`].
25#[derive(Clone, Copy, Debug, PartialEq, Eq)]
26pub enum AzureFault {
27    /// Access denied.
28    Auth,
29    /// Request timeout.
30    Timeout,
31}
32
33impl MapAzureClient {
34    /// Empty client.
35    #[must_use]
36    pub fn new() -> Self {
37        Self::default()
38    }
39
40    /// Insert secret.
41    #[must_use]
42    pub fn with_secret(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
43        self.secrets.insert(name.into(), value.into());
44        self
45    }
46
47    /// Force failures.
48    #[must_use]
49    pub fn with_fault(mut self, fault: AzureFault) -> Self {
50        self.fault = Some(fault);
51        self
52    }
53}
54
55#[async_trait]
56impl AzureKeyVaultClient for MapAzureClient {
57    async fn get_secret(&self, name: &str) -> Result<String> {
58        match self.fault {
59            Some(AzureFault::Auth) => return Err(Error::provider("azure-key-vault", "access denied")),
60            Some(AzureFault::Timeout) => return Err(Error::provider("azure-key-vault", "timeout")),
61            None => {}
62        }
63        self.secrets
64            .get(name)
65            .cloned()
66            .ok_or_else(|| Error::not_found(name))
67    }
68}
69
70/// Azure Key Vault provider.
71pub struct AzureKeyVaultProvider {
72    meta: ProviderMeta,
73    client: Arc<dyn AzureKeyVaultClient>,
74    vault_url: String,
75}
76
77impl AzureKeyVaultProvider {
78    /// Create provider. `vault_url` is retained for diagnostics / future HTTP clients.
79    #[must_use]
80    pub fn new(vault_url: impl Into<String>, client: Arc<dyn AzureKeyVaultClient>) -> Self {
81        Self {
82            meta: ProviderMeta {
83                id: ProviderId::new("azure-key-vault"),
84                name: "Azure Key Vault".into(),
85                capabilities: ProviderCapability {
86                    bulk: false,
87                    versioned: true,
88                    local: false,
89                },
90            },
91            client,
92            vault_url: vault_url.into(),
93        }
94    }
95
96    /// Vault base URL.
97    #[must_use]
98    pub fn vault_url(&self) -> &str {
99        &self.vault_url
100    }
101}
102
103#[async_trait]
104impl Provider for AzureKeyVaultProvider {
105    fn meta(&self) -> &ProviderMeta {
106        &self.meta
107    }
108
109    async fn get(&self, key: &str) -> Result<ConfigValue> {
110        // Azure secret names often use `-` instead of `_`.
111        let candidates = [key.to_string(), key.replace('_', "-")];
112        for name in &candidates {
113            match self.client.get_secret(name).await {
114                Ok(v) => return Ok(ConfigValue::secret(v)),
115                Err(Error::NotFound { .. }) => continue,
116                Err(e) => return Err(e),
117            }
118        }
119        Err(Error::not_found(key))
120    }
121}
122
123#[cfg(test)]
124mod tests {
125    use super::*;
126    use esh_test_support::{
127        run_provider_conformance, ProviderConformanceCfg, SAMPLE_SECRET, SAMPLE_TOKEN,
128    };
129
130    #[tokio::test]
131    async fn resolves_underscore_to_hyphen() {
132        let client = Arc::new(MapAzureClient::new().with_secret("db-password", "p"));
133        let p = AzureKeyVaultProvider::new("https://example.vault.azure.net", client);
134        assert_eq!(p.get("db_password").await.unwrap().as_str(), Some("p"));
135    }
136
137    #[tokio::test]
138    async fn azure_conformance() {
139        let client = Arc::new(MapAzureClient::new().with_secret("database_url", SAMPLE_SECRET));
140        let p = AzureKeyVaultProvider::new("https://example.vault.azure.net", client);
141        run_provider_conformance(
142            &p,
143            &ProviderConformanceCfg {
144                expected_id: "azure-key-vault".into(),
145                expected_capabilities: ProviderCapability {
146                    bulk: false,
147                    versioned: true,
148                    local: false,
149                },
150                present_key: "database_url".into(),
151                present_value: SAMPLE_SECRET.into(),
152                missing_key: "missing".into(),
153                fault_key: None,
154                health_ok: true,
155                test_get_many: true,
156            },
157        )
158        .await;
159    }
160
161    #[tokio::test]
162    async fn azure_auth_fault_no_leak() {
163        let client = Arc::new(
164            MapAzureClient::new()
165                .with_secret("api_token", SAMPLE_TOKEN)
166                .with_fault(AzureFault::Auth),
167        );
168        let p = AzureKeyVaultProvider::new("https://example.vault.azure.net", client);
169        let err = p.get("api_token").await.unwrap_err();
170        assert!(!err.to_string().contains(SAMPLE_TOKEN));
171    }
172}