pub mod error;
pub mod providers;
pub mod registry;
pub mod types;
pub use error::Error;
pub use providers::*;
pub use registry::ConfigRegistry;
pub use types::*;
pub fn create_default_registry() -> ConfigRegistry {
let mut registry = ConfigRegistry::default();
#[cfg(feature = "digital-ocean")]
{
registry.register(Box::new(providers::DOPublicIpProvider));
registry.register(Box::new(providers::DOPrivateIpProvider));
}
#[cfg(feature = "ipify")]
{
registry.register(Box::new(providers::IpifyProvider));
}
#[cfg(feature = "aws")]
{
registry.register(Box::new(providers::AWSPublicIpProvider));
registry.register(Box::new(providers::AWSPrivateIpProvider));
}
registry
}
#[cfg(feature = "clap")]
pub mod clap_resolver;
#[cfg(feature = "clap")]
pub use crate::clap_resolver::*;
#[cfg(test)]
mod tests {
use super::*;
use crate::types::ResolvedValue;
use async_trait::async_trait;
use std::net::IpAddr;
use std::str::FromStr;
struct MockProvider(&'static str, IpAddr);
#[async_trait]
impl ConfigProvider for MockProvider {
fn name(&self) -> &str {
self.0
}
async fn resolve(&self) -> Result<ResolvedValue, Error> {
Ok(ResolvedValue::Ip(self.1))
}
fn resolve_sync(&self) -> Result<ResolvedValue, Error> {
Ok(ResolvedValue::Ip(self.1))
}
}
#[tokio::test]
async fn test_resolve_static_ip() {
let registry = ConfigRegistry::default();
let ip: IpAddr = registry.resolve("127.0.0.1").await.unwrap();
assert_eq!(ip, IpAddr::from_str("127.0.0.1").unwrap());
}
#[tokio::test]
async fn test_resolve_provider_ip() {
let mut registry = ConfigRegistry::default();
registry.register(Box::new(MockProvider(
"DO_PUBLIC_IP",
"1.1.1.1".parse().unwrap(),
)));
let ip: IpAddr = registry.resolve("DO_PUBLIC_IP").await.unwrap();
assert_eq!(ip, IpAddr::from_str("1.1.1.1").unwrap());
}
#[tokio::test]
async fn test_resolve_socket_addr() {
let mut registry = ConfigRegistry::default();
registry.register(Box::new(MockProvider(
"DO_PUBLIC_IP",
"1.1.1.1".parse().unwrap(),
)));
let addr: std::net::SocketAddr = registry.resolve("DO_PUBLIC_IP:22222").await.unwrap();
assert_eq!(addr, "1.1.1.1:22222".parse().unwrap());
}
#[tokio::test]
async fn test_resolve_socket_addr_rejects_out_of_range_port() {
let registry = ConfigRegistry::default();
let error = registry
.resolve::<std::net::SocketAddr>("127.0.0.1:70000")
.await
.unwrap_err();
assert!(error.to_string().contains("70000"));
}
#[tokio::test]
async fn test_resolve_calc() {
let mut registry = ConfigRegistry::default();
registry.register(Box::new(MockProvider(
"DO_PUBLIC_IP",
"1.1.1.1".parse().unwrap(),
)));
let val: u64 = registry.resolve("CALC(DO_PUBLIC_IP+10000)").await.unwrap();
assert_eq!(val, 16843009 + 10000);
}
#[test]
fn test_resolve_sync() {
let mut registry = ConfigRegistry::default();
registry.register(Box::new(MockProvider(
"DO_PUBLIC_IP",
"1.1.1.1".parse().unwrap(),
)));
let ip: IpAddr = registry.resolve_sync("127.0.0.1").unwrap();
assert_eq!(ip, "127.0.0.1".parse::<IpAddr>().unwrap());
let ip: IpAddr = registry.resolve_sync("DO_PUBLIC_IP").unwrap();
assert_eq!(ip, "1.1.1.1".parse::<IpAddr>().unwrap());
let val: u64 = registry.resolve_sync("CALC(DO_PUBLIC_IP+10000)").unwrap();
assert_eq!(val, 16843009 + 10000);
let addr: std::net::SocketAddr = registry.resolve_sync("DO_PUBLIC_IP:3000").unwrap();
assert_eq!(addr, "1.1.1.1:3000".parse().unwrap());
let error = registry
.resolve_sync::<std::net::SocketAddr>("127.0.0.1:70000")
.unwrap_err();
assert!(error.to_string().contains("70000"));
}
#[test]
#[cfg(feature = "clap")]
fn test_clap_value_parser() {
use clap::Parser;
let mut registry = ConfigRegistry::default();
registry.register(Box::new(MockProvider(
"DO_PUBLIC_IP",
"1.1.1.1".parse().unwrap(),
)));
let _ = init_global_registry(registry);
#[derive(Debug, Parser)]
struct TestArgs {
#[arg(long, value_parser = clap_value_parser::<IpAddr>)]
ip: IpAddr,
#[arg(long, value_parser = clap_value_parser::<std::net::SocketAddr>)]
socket: std::net::SocketAddr,
#[arg(long, value_parser = clap_value_parser::<u32>)]
port: u32,
}
let args = TestArgs::parse_from([
"test_app",
"--ip",
"DO_PUBLIC_IP",
"--socket",
"DO_PUBLIC_IP:3000",
"--port",
"CALC(127.0.0.1+100)",
]);
assert_eq!(args.ip, "1.1.1.1".parse::<IpAddr>().unwrap());
assert_eq!(args.socket, "1.1.1.1:3000".parse().unwrap());
assert_eq!(args.port, 2130706533);
let error = TestArgs::try_parse_from([
"test_app",
"--ip",
"DO_PUBLIC_IP",
"--socket",
"127.0.0.1:70000",
"--port",
"1",
])
.unwrap_err();
assert!(error.to_string().contains("70000"));
}
}