1pub mod error;
10pub mod providers;
11pub mod registry;
12pub mod types;
13
14pub use error::Error;
15pub use providers::*;
16pub use registry::ConfigRegistry;
17pub use types::*;
18
19pub fn create_default_registry() -> ConfigRegistry {
28 let mut registry = ConfigRegistry::default();
29
30 #[cfg(feature = "digital-ocean")]
31 {
32 registry.register(Box::new(providers::DOPublicIpProvider));
33 registry.register(Box::new(providers::DOPrivateIpProvider));
34 }
35
36 #[cfg(feature = "ipify")]
37 {
38 registry.register(Box::new(providers::IpifyProvider));
39 }
40
41 #[cfg(feature = "aws")]
42 {
43 registry.register(Box::new(providers::AWSPublicIpProvider));
44 registry.register(Box::new(providers::AWSPrivateIpProvider));
45 }
46
47 registry
48}
49
50#[cfg(test)]
51mod tests {
52 use super::*;
53 use crate::types::ResolvedValue;
54 use async_trait::async_trait;
55 use std::net::IpAddr;
56 use std::str::FromStr;
57
58 struct MockProvider(&'static str, IpAddr);
59
60 #[async_trait]
61 impl ConfigProvider for MockProvider {
62 fn name(&self) -> &str {
63 self.0
64 }
65 async fn resolve(&self) -> Result<ResolvedValue, Error> {
66 Ok(ResolvedValue::Ip(self.1))
67 }
68 }
69
70 #[tokio::test]
71 async fn test_resolve_static_ip() {
72 let registry = ConfigRegistry::default();
73 let ip: IpAddr = registry.resolve("127.0.0.1").await.unwrap();
74 assert_eq!(ip, IpAddr::from_str("127.0.0.1").unwrap());
75 }
76
77 #[tokio::test]
78 async fn test_resolve_provider_ip() {
79 let mut registry = ConfigRegistry::default();
80 registry.register(Box::new(MockProvider(
81 "DO_PUBLIC_IP",
82 "1.1.1.1".parse().unwrap(),
83 )));
84 let ip: IpAddr = registry.resolve("DO_PUBLIC_IP").await.unwrap();
85 assert_eq!(ip, IpAddr::from_str("1.1.1.1").unwrap());
86 }
87
88 #[tokio::test]
89 async fn test_resolve_socket_addr() {
90 let mut registry = ConfigRegistry::default();
91 registry.register(Box::new(MockProvider(
92 "DO_PUBLIC_IP",
93 "1.1.1.1".parse().unwrap(),
94 )));
95 let addr: std::net::SocketAddr = registry.resolve("DO_PUBLIC_IP:22222").await.unwrap();
96 assert_eq!(addr, "1.1.1.1:22222".parse().unwrap());
97 }
98
99 #[tokio::test]
100 async fn test_resolve_calc() {
101 let mut registry = ConfigRegistry::default();
102 registry.register(Box::new(MockProvider(
103 "DO_PUBLIC_IP",
104 "1.1.1.1".parse().unwrap(),
105 )));
106 let val: u64 = registry.resolve("CALC(DO_PUBLIC_IP+10000)").await.unwrap();
109 assert_eq!(val, 16843009 + 10000);
110 }
111}