colin/hickory-dns
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

test(WIP): fix integration test

Browse Source
This commit is contained in:
XOR-op 2023-05-20 12:22:56 +08:00 committed by Benjamin Fry
parent 5ab85e297d
commit 293bd93783
8 changed files with 165 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
crates/async-std-resolver/src/lib.rs
View File

@ -96,7 +96,7 @@
use trust_dns_resolver::AsyncResolver;
use crate::runtime::AsyncStdRuntimeProvider;
use crate::runtime::AsyncStdConnectionProvider;
mod net;
mod runtime;
@ -104,7 +104,6 @@ mod runtime;
mod tests;
mod time;
use crate::proto::Executor;
pub use trust_dns_resolver::config;
pub use trust_dns_resolver::error::ResolveError;
pub use trust_dns_resolver::lookup;
@ -112,7 +111,7 @@ pub use trust_dns_resolver::lookup_ip;
pub use trust_dns_resolver::proto;
/// An AsyncResolver used with async_std
pub type AsyncStdResolver = AsyncResolver<AsyncStdRuntimeProvider>;
pub type AsyncStdResolver = AsyncResolver<AsyncStdConnectionProvider>;
/// Construct a new async-std based `AsyncResolver` with the provided configuration.
///
@ -131,7 +130,7 @@ pub async fn resolver(
config: config::ResolverConfig,
options: config::ResolverOpts,
) -> AsyncStdResolver {
AsyncStdResolver::new(config, options, AsyncStdRuntimeProvider::new())
AsyncStdResolver::new(config, options, AsyncStdConnectionProvider::default())
}
/// Constructs a new async-std based Resolver with the system configuration.
@ -140,5 +139,5 @@ pub async fn resolver(
#[cfg(any(unix, target_os = "windows"))]
#[cfg(feature = "system-config")]
pub async fn resolver_from_system_conf() -> Result<AsyncStdResolver, ResolveError> {
AsyncStdResolver::from_system_conf(AsyncStdRuntimeProvider::new())
AsyncStdResolver::from_system_conf(AsyncStdConnectionProvider::default())
}

41
crates/async-std-resolver/src/runtime.rs
View File

@ -8,11 +8,14 @@
use std::future::Future;
use std::net::SocketAddr;
use std::pin::Pin;
use trust_dns_resolver::config::{NameServerConfig, ResolverOpts};
use trust_dns_resolver::proto::error::ProtoError;
use trust_dns_resolver::proto::Executor;
use trust_dns_resolver::name_server::{RuntimeProvider, Spawn};
use trust_dns_resolver::name_server::{
ConnectionProvider, GenericConnector, RuntimeProvider, Spawn,
};
use crate::net::{AsyncStdTcpStream, AsyncStdUdpSocket};
use crate::proto::tcp::Connect;
@ -46,7 +49,7 @@ use crate::time::AsyncStdTime;
/// [timer]: crate::time
/// [mod]: index.html
/// [`new`]: #method.new
#[derive(Clone, Copy)]
#[derive(Clone, Copy, Default)]
pub struct AsyncStdRuntimeProvider;
impl Executor for AsyncStdRuntimeProvider {
@ -95,3 +98,37 @@ impl RuntimeProvider for AsyncStdRuntimeProvider {
Box::pin(AsyncStdUdpSocket::bind(local_addr))
}
}
#[derive(Clone, Default)]
pub struct AsyncStdConnectionProvider {
runtime_provider: AsyncStdRuntimeProvider,
connection_provider: GenericConnector<AsyncStdRuntimeProvider>,
}
impl Executor for AsyncStdConnectionProvider {
fn new() -> Self {
let p = AsyncStdRuntimeProvider::new();
Self {
runtime_provider: p,
connection_provider: GenericConnector::new(p),
}
}
fn block_on<F: Future>(&mut self, future: F) -> F::Output {
self.runtime_provider.block_on(future)
}
}
impl ConnectionProvider for AsyncStdConnectionProvider {
type Conn = <GenericConnector<AsyncStdRuntimeProvider> as ConnectionProvider>::Conn;
type FutureConn = <GenericConnector<AsyncStdRuntimeProvider> as ConnectionProvider>::FutureConn;
type RuntimeProvider = AsyncStdRuntimeProvider;
fn new_connection(
&self,
config: &NameServerConfig,
options: &ResolverOpts,
) -> Self::FutureConn {
self.connection_provider.new_connection(config, options)
}
}

127
crates/async-std-resolver/src/tests.rs
View File

@ -8,7 +8,7 @@ use crate::lookup::LookupFuture;
use crate::lookup_ip::LookupIpFuture;
use crate::proto::xfer::DnsRequest;
use crate::proto::Executor;
use crate::runtime::AsyncStdRuntimeProvider;
use crate::runtime::AsyncStdConnectionProvider;
use crate::AsyncStdResolver;
use crate::ResolveError;
@ -38,11 +38,11 @@ fn test_send_sync() {
#[test]
fn test_lookup_google() {
use testing::lookup_test;
let io_loop = AsyncStdRuntimeProvider::new();
let io_loop = AsyncStdConnectionProvider::new();
lookup_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(
lookup_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(
ResolverConfig::google(),
io_loop,
io_loop.clone(),
io_loop,
)
}
@ -50,10 +50,10 @@ fn test_lookup_google() {
#[test]
fn test_lookup_cloudflare() {
use testing::lookup_test;
let io_loop = AsyncStdRuntimeProvider::new();
lookup_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(
let io_loop = AsyncStdConnectionProvider::new();
lookup_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(
ResolverConfig::cloudflare(),
io_loop,
io_loop.clone(),
io_loop,
)
}
@ -61,10 +61,10 @@ fn test_lookup_cloudflare() {
#[test]
fn test_lookup_quad9() {
use testing::lookup_test;
let io_loop = AsyncStdRuntimeProvider::new();
lookup_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(
let io_loop = AsyncStdConnectionProvider::new();
lookup_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(
ResolverConfig::quad9(),
io_loop,
io_loop.clone(),
io_loop,
)
}
@ -72,31 +72,40 @@ fn test_lookup_quad9() {
#[test]
fn test_ip_lookup() {
use testing::ip_lookup_test;
let io_loop = AsyncStdRuntimeProvider::new();
ip_lookup_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(io_loop, io_loop)
let io_loop = AsyncStdConnectionProvider::new();
ip_lookup_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(
io_loop.clone(),
io_loop,
)
}
#[test]
fn test_ip_lookup_across_threads() {
use testing::ip_lookup_across_threads_test;
let io_loop = AsyncStdRuntimeProvider::new();
ip_lookup_across_threads_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(io_loop)
let io_loop = AsyncStdConnectionProvider::new();
ip_lookup_across_threads_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(io_loop)
}
#[test]
#[cfg(feature = "dnssec")]
fn test_sec_lookup() {
use testing::sec_lookup_test;
let io_loop = AsyncStdRuntimeProvider::new();
sec_lookup_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(io_loop, io_loop);
let io_loop = AsyncStdConnectionProvider::new();
sec_lookup_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(
io_loop.clone(),
io_loop,
);
}
#[test]
#[cfg(feature = "dnssec")]
fn test_sec_lookup_fails() {
use testing::sec_lookup_fails_test;
let io_loop = AsyncStdRuntimeProvider::new();
sec_lookup_fails_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(io_loop, io_loop);
let io_loop = AsyncStdConnectionProvider::new();
sec_lookup_fails_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(
io_loop.clone(),
io_loop,
);
}
#[test]
@ -105,8 +114,11 @@ fn test_sec_lookup_fails() {
#[cfg(feature = "system-config")]
fn test_system_lookup() {
use testing::system_lookup_test;
let io_loop = AsyncStdRuntimeProvider::new();
system_lookup_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(io_loop, io_loop);
let io_loop = AsyncStdConnectionProvider::new();
system_lookup_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(
io_loop.clone(),
io_loop,
);
}
#[test]
@ -116,94 +128,115 @@ fn test_system_lookup() {
#[cfg(unix)]
fn test_hosts_lookup() {
use testing::hosts_lookup_test;
let io_loop = AsyncStdRuntimeProvider::new();
hosts_lookup_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(io_loop, io_loop);
let io_loop = AsyncStdConnectionProvider::new();
hosts_lookup_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(
io_loop.clone(),
io_loop,
);
}
#[test]
fn test_fqdn() {
use testing::fqdn_test;
let io_loop = AsyncStdRuntimeProvider::new();
fqdn_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(io_loop, io_loop);
let io_loop = AsyncStdConnectionProvider::new();
fqdn_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(io_loop.clone(), io_loop);
}
#[test]
fn test_ndots() {
use testing::ndots_test;
let io_loop = AsyncStdRuntimeProvider::new();
ndots_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(io_loop, io_loop);
let io_loop = AsyncStdConnectionProvider::new();
ndots_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(io_loop.clone(), io_loop);
}
#[test]
fn test_large_ndots() {
use testing::large_ndots_test;
let io_loop = AsyncStdRuntimeProvider::new();
large_ndots_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(io_loop, io_loop);
let io_loop = AsyncStdConnectionProvider::new();
large_ndots_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(
io_loop.clone(),
io_loop,
);
}
#[test]
fn test_domain_search() {
use testing::domain_search_test;
let io_loop = AsyncStdRuntimeProvider::new();
domain_search_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(io_loop, io_loop);
let io_loop = AsyncStdConnectionProvider::new();
domain_search_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(
io_loop.clone(),
io_loop,
);
}
#[test]
fn test_search_list() {
use testing::search_list_test;
let io_loop = AsyncStdRuntimeProvider::new();
search_list_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(io_loop, io_loop);
let io_loop = AsyncStdConnectionProvider::new();
search_list_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(
io_loop.clone(),
io_loop,
);
}
#[test]
fn test_idna() {
use testing::idna_test;
let io_loop = AsyncStdRuntimeProvider::new();
idna_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(io_loop, io_loop);
let io_loop = AsyncStdConnectionProvider::new();
idna_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(io_loop.clone(), io_loop);
}
#[test]
fn test_localhost_ipv4() {
use testing::localhost_ipv4_test;
let io_loop = AsyncStdRuntimeProvider::new();
let io_loop = AsyncStdConnectionProvider::new();
localhost_ipv4_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(io_loop, io_loop);
localhost_ipv4_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(
io_loop.clone(),
io_loop,
);
}
#[test]
fn test_localhost_ipv6() {
use testing::localhost_ipv6_test;
let io_loop = AsyncStdRuntimeProvider::new();
let io_loop = AsyncStdConnectionProvider::new();
localhost_ipv6_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(io_loop, io_loop);
localhost_ipv6_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(
io_loop.clone(),
io_loop,
);
}
#[test]
fn test_search_ipv4_large_ndots() {
use testing::search_ipv4_large_ndots_test;
let io_loop = AsyncStdRuntimeProvider::new();
let io_loop = AsyncStdConnectionProvider::new();
search_ipv4_large_ndots_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(
io_loop, io_loop,
search_ipv4_large_ndots_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(
io_loop.clone(),
io_loop,
);
}
#[test]
fn test_search_ipv6_large_ndots() {
use testing::search_ipv6_large_ndots_test;
let io_loop = AsyncStdRuntimeProvider::new();
let io_loop = AsyncStdConnectionProvider::new();
search_ipv6_large_ndots_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(
io_loop, io_loop,
search_ipv6_large_ndots_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(
io_loop.clone(),
io_loop,
);
}
#[test]
fn test_search_ipv6_name_parse_fails() {
use testing::search_ipv6_name_parse_fails_test;
let io_loop = AsyncStdRuntimeProvider::new();
let io_loop = AsyncStdConnectionProvider::new();
search_ipv6_name_parse_fails_test::<AsyncStdRuntimeProvider, AsyncStdRuntimeProvider>(
io_loop, io_loop,
search_ipv6_name_parse_fails_test::<AsyncStdConnectionProvider, AsyncStdConnectionProvider>(
io_loop.clone(),
io_loop,
);
}

6
crates/recursor/src/recursor.rs
View File

@ -12,6 +12,7 @@ use futures_util::{future::select_all, FutureExt};
use lru_cache::LruCache;
use parking_lot::Mutex;
use tracing::{debug, info, warn};
use trust_dns_resolver::name_server::TokioConnectionProvider;
use crate::{
proto::{
@ -55,7 +56,8 @@ impl Recursor {
assert!(!roots.is_empty(), "roots must not be empty");
let opts = recursor_opts();
let roots = GenericNameServerPool::from_config(roots, &opts, TokioRuntimeProvider::new());
let roots =
GenericNameServerPool::from_config(roots, &opts, TokioConnectionProvider::default());
let roots = RecursorPool::from(Name::root(), roots);
let name_server_cache = Mutex::new(NameServerCache::new(100)); // TODO: make this configurable
let record_cache = DnsLru::new(100, TtlConfig::default());
@ -438,7 +440,7 @@ impl Recursor {
let ns = GenericNameServerPool::from_config(
config_group,
&recursor_opts(),
TokioRuntimeProvider::new(),
TokioConnectionProvider::default(),
);
let ns = RecursorPool::from(zone.clone(), ns);

6
crates/server/src/store/forwarder/authority.rs
View File

@ -8,7 +8,7 @@
use std::io;
use tracing::{debug, info};
use trust_dns_resolver::name_server::TokioRuntimeProvider;
use trust_dns_resolver::name_server::TokioConnectionProvider;
use crate::{
authority::{
@ -35,7 +35,7 @@ impl ForwardAuthority {
/// TODO: change this name to create or something
#[allow(clippy::new_without_default)]
#[doc(hidden)]
pub fn new(runtime: TokioRuntimeProvider) -> Result<Self, String> {
pub fn new(runtime: TokioConnectionProvider) -> Result<Self, String> {
let resolver = TokioAsyncResolver::from_system_conf(runtime)
.map_err(|e| format!("error constructing new Resolver: {e}"))?;
@ -77,7 +77,7 @@ impl ForwardAuthority {
let config = ResolverConfig::from_parts(None, vec![], name_servers);
let resolver = TokioAsyncResolver::new(config, options, TokioRuntimeProvider::new());
let resolver = TokioAsyncResolver::new(config, options, TokioConnectionProvider::default());
info!("forward resolver configured: {}: ", origin);

6
crates/server/tests/forwarder.rs
View File

@ -7,7 +7,7 @@ use std::str::FromStr;
use tokio::runtime::Runtime;
use trust_dns_proto::rr::{Name, RData, RecordType};
use trust_dns_resolver::name_server::TokioRuntimeProvider;
use trust_dns_resolver::name_server::TokioConnectionProvider;
use trust_dns_server::{
authority::{Authority, LookupObject},
store::forwarder::ForwardAuthority,
@ -17,8 +17,8 @@ use trust_dns_server::{
#[test]
fn test_lookup() {
let runtime = Runtime::new().expect("failed to create Tokio Runtime");
let forwarder =
ForwardAuthority::new(TokioRuntimeProvider::new()).expect("failed to create forwarder");
let forwarder = ForwardAuthority::new(TokioConnectionProvider::default())
.expect("failed to create forwarder");
let lookup = runtime
.block_on(forwarder.lookup(

63
tests/integration-tests/src/mock_client.rs
View File

@ -5,8 +5,8 @@
// http://opensource.org/licenses/MIT>, at your option. This file may not be
// copied, modified, or distributed except according to those terms.
use std::any::TypeId;
use std::error::Error;
use std::marker::PhantomData;
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use std::pin::Pin;
use std::sync::{Arc, Mutex};
@ -27,7 +27,7 @@ use trust_dns_proto::xfer::{DnsHandle, DnsRequest, DnsResponse};
use trust_dns_proto::TokioTime;
use trust_dns_resolver::config::{NameServerConfig, ResolverOpts};
use trust_dns_resolver::error::ResolveError;
use trust_dns_resolver::name_server::{CreateConnection, RuntimeProvider};
use trust_dns_resolver::name_server::{ConnectionProvider, RuntimeProvider};
use trust_dns_resolver::TokioHandle;
pub struct TcpPlaceholder;
@ -100,21 +100,11 @@ impl DnsUdpSocket for UdpPlaceholder {
}
}
#[derive(Clone)]
pub struct MockConnProvider<O: OnSend> {
pub on_send: O,
}
impl Default for MockConnProvider<DefaultOnSend> {
fn default() -> Self {
Self {
on_send: DefaultOnSend,
}
}
}
#[derive(Clone, Default)]
pub struct MockRuntimeProvider;
#[allow(clippy::type_complexity)]
impl<O: OnSend + Unpin> RuntimeProvider for MockConnProvider<O> {
impl RuntimeProvider for MockRuntimeProvider {
type Handle = TokioHandle;
type Timer = TokioTime;
type Udp = UdpPlaceholder;
@ -140,6 +130,30 @@ impl<O: OnSend + Unpin> RuntimeProvider for MockConnProvider<O> {
}
}
#[derive(Clone)]
pub struct MockConnProvider<O: OnSend + Unpin, E> {
pub on_send: O,
pub _p: PhantomData<E>,
}
impl<O: OnSend + Unpin> ConnectionProvider for MockConnProvider<O, ResolveError> {
type Conn = MockClientHandle<O, ResolveError>;
type FutureConn = Pin<Box<dyn Send + Future<Output = Result<Self::Conn, ResolveError>>>>;
type RuntimeProvider = MockRuntimeProvider;
fn new_connection(
&self,
_config: &NameServerConfig,
_options: &ResolverOpts,
) -> Self::FutureConn {
println!("MockConnProvider::new_connection");
Box::pin(future::ok(MockClientHandle::mock_on_send(
vec![],
self.on_send.clone(),
)))
}
}
#[derive(Clone)]
pub struct MockClientHandle<O: OnSend, E> {
messages: Arc<Mutex<Vec<Result<DnsResponse, E>>>>,
@ -175,25 +189,6 @@ impl<O: OnSend, E> MockClientHandle<O, E> {
}
}
impl<O: OnSend, E: Send + 'static> CreateConnection for MockClientHandle<O, E> {
fn new_connection<P: RuntimeProvider>(
runtime_provider: &P,
_config: &NameServerConfig,
_options: &ResolverOpts,
) -> Box<dyn Future<Output = Result<Self, ResolveError>> + Send + Unpin + 'static> {
if TypeId::of::<P>() != TypeId::of::<MockConnProvider<O>>() {
panic!("Type Mismatched. Unsafe to cast")
}
// Safety: we have checked the type
let provider = unsafe { &*(runtime_provider as *const P as *const MockConnProvider<O>) };
println!("MockConnProvider::new_connection");
Box::new(future::ok(MockClientHandle::mock_on_send(
vec![],
provider.on_send.clone(),
)))
}
}
impl<O: OnSend + Unpin, E> DnsHandle for MockClientHandle<O, E>
where
E: From<ProtoError> + Error + Clone + Send + Unpin + 'static,

6
tests/integration-tests/tests/name_server_pool_tests.rs
View File

@ -21,9 +21,8 @@ use trust_dns_resolver::name_server::{NameServer, NameServerPool};
const DEFAULT_SERVER_ADDR: IpAddr = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
type MockedNameServer<O> = NameServer<MockClientHandle<O, ResolveError>, MockConnProvider<O>>;
type MockedNameServerPool<O> =
NameServerPool<MockClientHandle<O, ResolveError>, MockConnProvider<O>>;
type MockedNameServer<O> = NameServer<MockConnProvider<O, ResolveError>>;
type MockedNameServerPool<O> = NameServerPool<MockConnProvider<O, ResolveError>>;
#[cfg(test)]
fn mock_nameserver(
@ -76,6 +75,7 @@ fn mock_nameserver_on_send_nx<O: OnSend + Unpin>(
) -> MockedNameServer<O> {
let conn_provider = MockConnProvider {
on_send: on_send.clone(),
_p: Default::default(),
};
let client = MockClientHandle::mock_on_send(messages, on_send);