use std::net::{IpAddr, SocketAddr};
use std::time::{Duration, Instant};
use super::cache::DnsCache;
use super::entry::DnsEntry;
use crate::network::EndpointKey;
fn entry(hostname: &str, port: u16, addresses: Vec<SocketAddr>, ttl: Duration) -> DnsEntry {
DnsEntry::new(
EndpointKey::new(hostname, port),
addresses,
Instant::now(),
ttl,
true,
)
}
fn create_test_cache() -> DnsCache {
DnsCache::with_ttl(10, 1) }
#[test]
fn test_mark_bad_removes_only_selected_address() {
let mut cache = create_test_cache();
let good: SocketAddr = "127.0.0.1:80".parse().unwrap();
let bad: SocketAddr = "127.0.0.2:80".parse().unwrap();
cache.cache.insert(
EndpointKey::new("mirror.test", 80),
entry("mirror.test", 80, vec![bad, good], Duration::from_secs(60)),
);
cache.mark_bad("mirror.test", bad);
assert_eq!(
cache.resolve_no_network("mirror.test", 80).unwrap(),
vec![good]
);
}
#[test]
fn test_mark_bad_preserves_candidate_state_until_cache_removal() {
let mut cache = create_test_cache();
let address: SocketAddr = "127.0.0.1:80".parse().unwrap();
let key = EndpointKey::new("mirror.test", 80);
cache.cache.insert(
key.clone(),
entry("mirror.test", 80, vec![address], Duration::from_secs(60)),
);
cache.mark_bad("mirror.test", address);
assert!(cache.cache.contains_key(&key));
assert!(
cache
.resolve_no_network("mirror.test", 80)
.unwrap()
.is_empty()
);
assert!(!cache.cache[&key].addresses[0].is_good());
}
#[test]
fn test_cache_keys_include_port() {
let mut cache = create_test_cache();
let http: SocketAddr = "127.0.0.1:80".parse().unwrap();
let https: SocketAddr = "127.0.0.1:443".parse().unwrap();
cache.cache.insert(
EndpointKey::new("mirror.test", 80),
entry("mirror.test", 80, vec![http], Duration::from_secs(60)),
);
cache.cache.insert(
EndpointKey::new("mirror.test", 443),
entry("mirror.test", 443, vec![https], Duration::from_secs(60)),
);
cache.mark_bad("mirror.test", http);
assert!(
cache
.resolve_no_network("mirror.test", 80)
.unwrap()
.is_empty()
);
assert_eq!(
cache.resolve_no_network("mirror.test", 443).unwrap(),
vec![https]
);
cache.remove_cached("mirror.test", 80);
assert!(cache.resolve_no_network("mirror.test", 80).is_err());
assert_eq!(
cache.resolve_no_network("mirror.test", 443).unwrap(),
vec![https]
);
}
#[test]
fn test_negative_cache_keys_include_port() {
let mut cache = create_test_cache();
cache.record_failure("mirror.test", 80);
assert!(
cache
.resolve_no_network("mirror.test", 80)
.unwrap_err()
.to_string()
.contains("recently failed")
);
assert!(
cache
.resolve_no_network("mirror.test", 443)
.unwrap_err()
.to_string()
.contains("No cached entry")
);
}
#[test]
fn test_remove_cached_clears_positive_and_negative_entries() {
let mut cache = create_test_cache();
cache.record_failure("mirror.test", 80);
cache.remove_cached("mirror.test", 80);
assert!(matches!(
cache.resolve_no_network("mirror.test", 80),
Err(crate::error::Aria2Error::NameResolve(message)) if message.contains("No cached entry")
));
}
#[test]
fn test_dns_entry_is_expired() {
let entry = entry("test.com", 80, vec![], Duration::from_secs(60));
assert!(!entry.is_expired());
let expired_entry = DnsEntry::new(
EndpointKey::new("old.com", 80),
vec![],
Instant::now() - Duration::from_secs(61),
Duration::from_secs(60),
false,
);
assert!(expired_entry.is_expired());
}
#[test]
fn test_dns_entry_best_address_ipv4_preferred() {
let ipv6_addr: SocketAddr = "[::1]:8080".parse().unwrap();
let ipv4_addr: SocketAddr = "127.0.0.1:8080".parse().unwrap();
let entry = entry(
"mixed.com",
8080,
vec![ipv6_addr, ipv4_addr],
Duration::from_secs(60),
);
let best = entry.best_address().unwrap();
assert_eq!(best, ipv4_addr);
}
#[test]
fn test_dns_entry_best_address_no_ipv4() {
let ipv6_addr: SocketAddr = "[::1]:8080".parse().unwrap();
let entry = entry(
"ipv6only.com",
8080,
vec![ipv6_addr],
Duration::from_secs(60),
);
let best = entry.best_address().unwrap();
assert_eq!(best, ipv6_addr);
}
#[test]
fn test_dns_entry_best_address_empty() {
let entry = entry("empty.com", 80, vec![], Duration::from_secs(60));
assert!(entry.best_address().is_none());
}
#[test]
fn test_dns_cache_creation() {
let cache = DnsCache::new();
assert!(cache.is_empty());
assert_eq!(cache.default_ttl(), Duration::from_secs(300));
assert_eq!(cache.negative_ttl(), Duration::from_secs(60));
}
#[test]
fn test_dns_cache_with_custom_ttl() {
let cache = DnsCache::with_ttl(600, 30);
assert_eq!(cache.default_ttl(), Duration::from_secs(600));
assert_eq!(cache.negative_ttl(), Duration::from_secs(30));
}
#[test]
fn test_dns_cache_clear() {
let mut cache = create_test_cache();
let entry = entry(
"example.com",
80,
vec!["127.0.0.1:80".parse().unwrap()],
Duration::from_secs(60),
);
cache
.cache
.insert(EndpointKey::new("example.com", 80), entry);
cache
.negative_entries
.insert(EndpointKey::new("failed.com", 80), Instant::now());
assert_eq!(cache.len(), 1);
cache.clear();
assert!(cache.is_empty());
assert!(cache.negative_entries.is_empty());
}
#[tokio::test]
async fn test_resolve_caches_result() {
let mut cache = create_test_cache();
let result1 = cache.resolve("localhost", 80).await;
assert!(
result1.is_ok(),
"First resolve of localhost should succeed: {:?}",
result1.err()
);
let addrs1 = result1.unwrap();
assert!(
!addrs1.is_empty(),
"localhost should resolve to at least one address"
);
let result2 = cache.resolve("localhost", 80).await;
assert!(result2.is_ok(), "Second resolve should succeed from cache");
let addrs2 = result2.unwrap();
assert_eq!(
addrs1, addrs2,
"Cached result should match original resolution"
);
assert_eq!(cache.len(), 1);
}
#[test]
fn test_negative_cache_blocks_retry() {
let mut cache = DnsCache::with_ttl(300, 2);
cache.record_failure("test-host.invalid", 80);
let result = cache.resolve_no_network("test-host.invalid", 80);
assert!(
result.is_err(),
"Lookup should be blocked by negative cache"
);
let err_msg = result.unwrap_err().to_string();
assert!(
err_msg.contains("recently failed"),
"Error should mention recent failure: {}",
err_msg
);
}
#[test]
fn test_purge_expired_removes_old() {
let mut cache = DnsCache::with_ttl(1, 60);
let expired_entry = DnsEntry::new(
EndpointKey::new("expired.example.com", 80),
vec!["10.0.0.1:80".parse().unwrap()],
Instant::now() - Duration::from_secs(5),
Duration::from_secs(1),
true,
);
cache
.cache
.insert(EndpointKey::new("expired.example.com", 80), expired_entry);
let fresh_entry = entry(
"fresh.example.com",
80,
vec!["10.0.0.2:80".parse().unwrap()],
Duration::from_secs(3600),
);
cache
.cache
.insert(EndpointKey::new("fresh.example.com", 80), fresh_entry);
assert_eq!(cache.len(), 2, "Should have 2 entries before purge");
let removed = cache.purge_expired();
assert_eq!(removed, 1, "Should remove exactly 1 expired entry");
assert_eq!(cache.len(), 1, "Should have 1 entry remaining");
assert!(
cache
.cache
.contains_key(&EndpointKey::new("fresh.example.com", 80)),
"Fresh entry should still exist"
);
assert!(
!cache
.cache
.contains_key(&EndpointKey::new("expired.example.com", 80)),
"Expired entry should be removed"
);
}
#[tokio::test]
async fn test_ipv4_preferred_sorting() {
let mut cache = create_test_cache();
let result = cache.resolve("localhost", 8080).await;
assert!(
result.is_ok(),
"localhost resolution should succeed: {:?}",
result.err()
);
let addrs = result.unwrap();
let has_ipv4 = addrs.iter().any(|a| matches!(a.ip(), IpAddr::V4(_)));
let has_ipv6 = addrs.iter().any(|a| matches!(a.ip(), IpAddr::V6(_)));
if has_ipv4 && has_ipv6 {
let first_ipv4_pos = addrs
.iter()
.position(|a| matches!(a.ip(), IpAddr::V4(_)))
.unwrap();
let first_ipv6_pos = addrs
.iter()
.position(|a| matches!(a.ip(), IpAddr::V6(_)))
.unwrap();
assert!(
first_ipv4_pos < first_ipv6_pos,
"IPv4 addresses should come before IPv6 when preferred. Got order: {:?}",
addrs
);
}
cache.set_ipv4_preference(false);
let result2 = cache.force_refresh("localhost", 8080).await;
assert!(result2.is_ok(), "Force refresh should succeed");
}
#[test]
fn test_force_refresh_clears_cache_entry() {
let mut cache = create_test_cache();
let entry = entry(
"preloaded.com",
443,
vec!["192.168.1.1:443".parse().unwrap()],
Duration::from_secs(3600),
);
cache
.cache
.insert(EndpointKey::new("preloaded.com", 443), entry);
assert_eq!(cache.len(), 1);
}
#[test]
fn test_default_impl() {
let cache = DnsCache::default();
assert!(cache.is_empty());
assert_eq!(cache.default_ttl(), Duration::from_secs(300));
}
#[tokio::test]
async fn test_async_dns_resolves_localhost() {
let mut cache = DnsCache::with_ttl(300, 60);
let result = cache.resolve("localhost", 80).await;
assert!(
result.is_ok(),
"localhost should resolve: {:?}",
result.err()
);
let addrs = result.unwrap();
assert!(!addrs.is_empty(), "should have at least one address");
assert_eq!(cache.len(), 1, "localhost should be cached after resolve");
}
#[tokio::test]
async fn test_dns_ttl_capped_at_default() {
let mut cache = DnsCache::with_ttl(60, 10); let _ = cache.resolve("localhost", 80).await;
if let Some(entry) = cache.cache.get(&EndpointKey::new("localhost", 80)) {
assert!(
entry.ttl <= Duration::from_secs(60),
"ttl should be capped at default, got {:?}",
entry.ttl
);
}
}