change default name resolver and allow custom resolvers (#248)

actix-tls/tests/test_connect.rs

@@ -1,17 +1,15 @@
 use std::io;
+use std::net::SocketAddr;
 
 use actix_codec::{BytesCodec, Framed};
 use actix_rt::net::TcpStream;
 use actix_server::TestServer;
 use actix_service::{fn_service, Service, ServiceFactory};
 use bytes::Bytes;
+use futures_core::future::LocalBoxFuture;
 use futures_util::sink::SinkExt;
 
-use actix_tls::connect::{
-    self as actix_connect,
-    resolver::{ResolverConfig, ResolverOpts},
-    Connect,
-};
+use actix_tls::connect::{self as actix_connect, Connect, Resolve, Resolver};
 
 #[cfg(all(feature = "connect", feature = "openssl"))]
 #[actix_rt::test]
@@ -57,14 +55,13 @@ async fn test_static_str() {
         })
     });
 
-    let resolver = actix_connect::start_default_resolver().await.unwrap();
-    let mut conn = actix_connect::new_connector(resolver.clone());
+    let mut conn = actix_connect::default_connector();
 
     let con = conn.call(Connect::with("10", srv.addr())).await.unwrap();
     assert_eq!(con.peer_addr().unwrap(), srv.addr());
 
     let connect = Connect::new(srv.host().to_owned());
-    let mut conn = actix_connect::new_connector(resolver);
+    let mut conn = actix_connect::default_connector();
     let con = conn.call(connect).await;
     assert!(con.is_err());
 }
@@ -79,10 +76,53 @@ async fn test_new_service() {
         })
     });
 
-    let resolver =
-        actix_connect::start_resolver(ResolverConfig::default(), ResolverOpts::default())
-            .await
-            .unwrap();
+    let factory = actix_connect::default_connector_factory();
+
+    let mut conn = factory.new_service(()).await.unwrap();
+    let con = conn.call(Connect::with("10", srv.addr())).await.unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}
+
+#[actix_rt::test]
+async fn test_custom_resolver() {
+    use trust_dns_resolver::TokioAsyncResolver;
+
+    let srv = TestServer::with(|| {
+        fn_service(|io: TcpStream| async {
+            let mut framed = Framed::new(io, BytesCodec);
+            framed.send(Bytes::from_static(b"test")).await?;
+            Ok::<_, io::Error>(())
+        })
+    });
+
+    struct MyResolver {
+        trust_dns: TokioAsyncResolver,
+    }
+
+    impl Resolve for MyResolver {
+        fn lookup<'a>(
+            &'a self,
+            host: &'a str,
+            port: u16,
+        ) -> LocalBoxFuture<'a, Result<Vec<SocketAddr>, Box<dyn std::error::Error>>> {
+            Box::pin(async move {
+                let res = self
+                    .trust_dns
+                    .lookup_ip(host)
+                    .await?
+                    .iter()
+                    .map(|ip| SocketAddr::new(ip, port))
+                    .collect();
+                Ok(res)
+            })
+        }
+    }
+
+    let resolver = MyResolver {
+        trust_dns: TokioAsyncResolver::tokio_from_system_conf().unwrap(),
+    };
+
+    let resolver = Resolver::new_custom(resolver);
 
     let factory = actix_connect::new_connector_factory(resolver);