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 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.state.write().unwrap().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 cache = create_test_cache();
let address: SocketAddr = "127.0.0.1:80".parse().unwrap();
let key = EndpointKey::new("mirror.test", 80);
cache.state.write().unwrap().cache.insert(
key.clone(),
entry("mirror.test", 80, vec![address], Duration::from_secs(60)),
);
cache.mark_bad("mirror.test", address);
assert!(cache.state.read().unwrap().cache.contains_key(&key));
assert!(
cache
.resolve_no_network("mirror.test", 80)
.unwrap()
.is_empty()
);
assert!(!cache.state.read().unwrap().cache[&key].addresses[0].is_good());
}
#[test]
fn test_cache_keys_include_port() {
let 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.state.write().unwrap().cache.insert(
EndpointKey::new("mirror.test", 80),
entry("mirror.test", 80, vec![http], Duration::from_secs(60)),
);
cache.state.write().unwrap().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 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 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));
assert_eq!(cache.dns_timeout(), Duration::from_secs(30));
}
#[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));
assert_eq!(cache.dns_timeout(), Duration::from_secs(30));
}
#[test]
fn test_dns_cache_with_custom_timeout() {
let cache = DnsCache::with_dns_timeout(Duration::from_secs(7));
assert_eq!(cache.dns_timeout(), Duration::from_secs(7));
}
#[test]
fn test_dns_cache_clear() {
let cache = create_test_cache();
let entry = entry(
"example.com",
80,
vec!["127.0.0.1:80".parse().unwrap()],
Duration::from_secs(60),
);
cache
.state
.write()
.unwrap()
.cache
.insert(EndpointKey::new("example.com", 80), entry);
cache
.state
.write()
.unwrap()
.negative_entries
.insert(EndpointKey::new("failed.com", 80), Instant::now());
assert_eq!(cache.len(), 1);
cache.clear();
assert!(cache.is_empty());
assert!(cache.state.read().unwrap().negative_entries.is_empty());
}
#[tokio::test]
async fn test_resolve_caches_result() {
let 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);
}
#[tokio::test]
async fn test_resolve_with_refresh_replaces_exhausted_candidates() {
let cache = create_test_cache();
let initial = cache
.resolve("localhost", 80)
.await
.expect("localhost should resolve");
assert!(!initial.is_empty());
for address in &initial {
cache.mark_bad("localhost", *address);
}
assert!(
cache
.resolve_no_network("localhost", 80)
.expect("the exhausted entry should still be cached")
.is_empty()
);
let refreshed = cache
.resolve_with_refresh("localhost", 80)
.await
.expect("refresh should resolve localhost again");
assert!(!refreshed.is_empty());
assert_eq!(
cache
.resolve_no_network("localhost", 80)
.expect("the refreshed entry should be cached"),
refreshed
);
}
#[tokio::test]
async fn test_explicit_dns_server_is_used_for_resolution() {
use tokio::net::UdpSocket;
let socket = UdpSocket::bind("127.0.0.1:0")
.await
.expect("DNS fixture must bind a UDP socket");
let server_address = socket
.local_addr()
.expect("DNS fixture must expose its local address");
let standby_socket = UdpSocket::bind("127.0.0.1:0")
.await
.expect("standby DNS fixture must bind a UDP socket");
let standby_address = standby_socket.local_addr().unwrap();
let standby = tokio::spawn(async move {
let mut request = [0u8; 512];
tokio::time::timeout(
Duration::from_millis(400),
standby_socket.recv_from(&mut request),
)
.await
.is_err()
});
let server = tokio::spawn(async move {
let mut request = [0u8; 512];
for _ in 0..4 {
let (length, peer) = socket
.recv_from(&mut request)
.await
.expect("DNS fixture must receive a query");
assert!(length >= 17, "DNS query must contain a question");
let mut question_end = 12;
loop {
let label_length = request[question_end] as usize;
question_end += 1;
if label_length == 0 {
question_end += 4;
break;
}
question_end += label_length;
}
let qtype = u16::from_be_bytes([request[question_end - 4], request[question_end - 3]]);
let mut response = Vec::with_capacity(question_end + 32);
response.extend_from_slice(&request[..2]);
response.extend_from_slice(&[0x81, 0x80, 0, 1, 0, 1, 0, 0, 0, 0]);
response.extend_from_slice(&request[12..question_end]);
response.extend_from_slice(&[0xc0, 0x0c]);
if qtype == 28 {
response.extend_from_slice(&[0, 28, 0, 1, 0, 0, 0, 60, 0, 16]);
response.extend_from_slice(&[0; 15]);
response.push(1);
} else {
response.extend_from_slice(&[0, 1, 0, 1, 0, 0, 0, 60, 0, 4, 127, 0, 0, 1]);
}
socket
.send_to(&response, peer)
.await
.expect("DNS fixture must send a response");
if qtype == 1 {
break;
}
}
});
let cache = DnsCache::with_dns_servers(
Duration::from_secs(2),
vec![server_address, standby_address],
);
let resolved = cache
.resolve("custom.test", 80)
.await
.expect("the configured DNS server should resolve custom.test");
assert!(
resolved.iter().any(|address| address.ip().is_loopback()),
"configured DNS response must reach the resolver: {resolved:?}"
);
tokio::time::timeout(Duration::from_secs(2), server)
.await
.expect("DNS fixture must finish promptly")
.expect("DNS fixture task must not fail");
assert!(
standby.await.unwrap(),
"standby must not receive duplicate queries"
);
}
#[tokio::test]
async fn explicit_dns_uses_backup_after_primary_times_out() {
use tokio::net::UdpSocket;
let primary = UdpSocket::bind("127.0.0.1:0").await.unwrap();
let primary_address = primary.local_addr().unwrap();
let primary_task = tokio::spawn(async move {
let mut packet = [0u8; 512];
tokio::time::timeout(Duration::from_secs(2), primary.recv_from(&mut packet))
.await
.expect("primary must receive the first query")
.expect("primary query receive must succeed");
});
let backup = UdpSocket::bind("127.0.0.1:0").await.unwrap();
let backup_address = backup.local_addr().unwrap();
let backup_task = tokio::spawn(async move {
let mut packet = [0u8; 512];
let mut query_count = 0;
let mut answered_a = false;
while !answered_a {
let Ok(Ok((length, peer))) =
tokio::time::timeout(Duration::from_secs(8), backup.recv_from(&mut packet)).await
else {
break;
};
query_count += 1;
let mut question_end = 12;
loop {
let label_length = packet[question_end] as usize;
question_end += 1;
if label_length == 0 {
question_end += 4;
break;
}
question_end += label_length;
}
let qtype = u16::from_be_bytes([packet[question_end - 4], packet[question_end - 3]]);
let mut response = Vec::with_capacity(question_end + 16);
response.extend_from_slice(&packet[..2]);
let is_a_query = qtype == 1;
let answer_count = u16::from(is_a_query);
response.extend_from_slice(&[0x81, 0x80, 0, 1]);
response.extend_from_slice(&answer_count.to_be_bytes());
response.extend_from_slice(&[0, 0, 0, 0]);
response.extend_from_slice(&packet[12..question_end]);
if is_a_query {
response.extend_from_slice(&[0xc0, 0x0c, 0, 1, 0, 1, 0, 0, 0, 30, 0, 4]);
response.extend_from_slice(&[127, 0, 0, 1]);
}
assert!(length >= question_end);
backup.send_to(&response, peer).await.unwrap();
answered_a = is_a_query;
}
query_count
});
let cache = DnsCache::with_dns_servers(
Duration::from_secs(7),
vec![primary_address, backup_address],
);
let addresses = cache
.resolve("failover.test", 80)
.await
.expect("backup server should resolve after primary timeout");
assert!(addresses.iter().any(|address| address.ip().is_loopback()));
primary_task.await.unwrap();
let backup_queries = backup_task.await.unwrap();
assert!(
backup_queries > 0,
"backup server must receive fallback queries"
);
}
#[tokio::test]
async fn test_explicit_dns_failure_does_not_fall_back_to_system_resolver() {
use tokio::net::UdpSocket;
let socket = UdpSocket::bind("127.0.0.1:0")
.await
.expect("DNS fixture must bind a UDP socket");
let server_address = socket
.local_addr()
.expect("DNS fixture must expose its local address");
let server = tokio::spawn(async move {
let mut request = [0u8; 512];
for _ in 0..4 {
let Ok(Ok((length, peer))) =
tokio::time::timeout(Duration::from_millis(250), socket.recv_from(&mut request))
.await
else {
break;
};
let mut question_end = 12;
loop {
let label_length = request[question_end] as usize;
question_end += 1;
if label_length == 0 {
question_end += 4;
break;
}
question_end += label_length;
}
let qtype = u16::from_be_bytes([request[question_end - 4], request[question_end - 3]]);
let mut response = Vec::with_capacity(question_end);
response.extend_from_slice(&request[..2]);
response.extend_from_slice(&[0x81, 0x83, 0, 1, 0, 0, 0, 0, 0, 0]);
response.extend_from_slice(&request[12..question_end]);
socket
.send_to(&response, peer)
.await
.expect("DNS fixture must send NXDOMAIN");
assert!(
length >= question_end,
"DNS query must contain its question"
);
if qtype == 1 {
break;
}
}
});
let cache = DnsCache::with_dns_servers(Duration::from_secs(2), vec![server_address]);
let error = cache
.resolve("explicit-only.invalid", 80)
.await
.expect_err("explicit DNS NXDOMAIN must not resolve through system DNS");
assert!(
error
.to_string()
.contains("using explicitly configured servers"),
"unexpected DNS error: {error}"
);
assert!(
cache
.state
.read()
.unwrap()
.negative_entries
.contains_key(&EndpointKey::new("explicit-only.invalid", 80))
);
tokio::time::timeout(Duration::from_secs(2), server)
.await
.expect("DNS fixture must finish promptly")
.expect("DNS fixture task must not fail");
}
#[test]
fn test_negative_cache_blocks_retry() {
let 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 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
.state
.write()
.unwrap()
.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
.state
.write()
.unwrap()
.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
.state
.read()
.unwrap()
.cache
.contains_key(&EndpointKey::new("fresh.example.com", 80)),
"Fresh entry should still exist"
);
assert!(
!cache
.state
.read()
.unwrap()
.cache
.contains_key(&EndpointKey::new("expired.example.com", 80)),
"Expired entry should be removed"
);
}
#[tokio::test]
async fn test_ipv4_preferred_sorting() {
let 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 cache = create_test_cache();
let entry = entry(
"preloaded.com",
443,
vec!["192.168.1.1:443".parse().unwrap()],
Duration::from_secs(3600),
);
cache
.state
.write()
.unwrap()
.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 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 cache = DnsCache::with_ttl(60, 10); let _ = cache.resolve("localhost", 80).await;
if let Some(entry) = cache
.state
.read()
.unwrap()
.cache
.get(&EndpointKey::new("localhost", 80))
{
assert!(
entry.ttl <= Duration::from_secs(60),
"ttl should be capped at default, got {:?}",
entry.ttl
);
}
}