1 use std::io;
2
3 use actix_codec::{BytesCodec, Framed};
4 use actix_rt::net::TcpStream;
5 use actix_service::{fn_service, Service, ServiceFactory};
6 use actix_testing::TestServer;
7 use bytes::Bytes;
8 use futures::SinkExt;
9
10 use actix_connect::resolver::{ResolverConfig, ResolverOpts};
11 use actix_connect::Connect;
12
13 #[cfg(feature = "openssl")]
14 #[actix_rt::test]
test_string()15 async fn test_string() {
16 let srv = TestServer::with(|| {
17 fn_service(|io: TcpStream| {
18 async {
19 let mut framed = Framed::new(io, BytesCodec);
20 framed.send(Bytes::from_static(b"test")).await?;
21 Ok::<_, io::Error>(())
22 }
23 })
24 });
25
26 let mut conn = actix_connect::default_connector();
27 let addr = format!("localhost:{}", srv.port());
28 let con = conn.call(addr.into()).await.unwrap();
29 assert_eq!(con.peer_addr().unwrap(), srv.addr());
30 }
31
32 #[cfg(feature = "rustls")]
33 #[actix_rt::test]
test_rustls_string()34 async fn test_rustls_string() {
35 let srv = TestServer::with(|| {
36 fn_service(|io: TcpStream| {
37 async {
38 let mut framed = Framed::new(io, BytesCodec);
39 framed.send(Bytes::from_static(b"test")).await?;
40 Ok::<_, io::Error>(())
41 }
42 })
43 });
44
45 let mut conn = actix_connect::default_connector();
46 let addr = format!("localhost:{}", srv.port());
47 let con = conn.call(addr.into()).await.unwrap();
48 assert_eq!(con.peer_addr().unwrap(), srv.addr());
49 }
50
51 #[actix_rt::test]
test_static_str()52 async fn test_static_str() {
53 let srv = TestServer::with(|| {
54 fn_service(|io: TcpStream| {
55 async {
56 let mut framed = Framed::new(io, BytesCodec);
57 framed.send(Bytes::from_static(b"test")).await?;
58 Ok::<_, io::Error>(())
59 }
60 })
61 });
62
63 let resolver = actix_connect::start_default_resolver();
64 let mut conn = actix_connect::new_connector(resolver.clone());
65
66 let con = conn.call(Connect::with("10", srv.addr())).await.unwrap();
67 assert_eq!(con.peer_addr().unwrap(), srv.addr());
68
69 let connect = Connect::new(srv.host().to_owned());
70 let mut conn = actix_connect::new_connector(resolver);
71 let con = conn.call(connect).await;
72 assert!(con.is_err());
73 }
74
75 #[actix_rt::test]
test_new_service()76 async fn test_new_service() {
77 let srv = TestServer::with(|| {
78 fn_service(|io: TcpStream| {
79 async {
80 let mut framed = Framed::new(io, BytesCodec);
81 framed.send(Bytes::from_static(b"test")).await?;
82 Ok::<_, io::Error>(())
83 }
84 })
85 });
86
87 let resolver =
88 actix_connect::start_resolver(ResolverConfig::default(), ResolverOpts::default());
89
90 let factory = actix_connect::new_connector_factory(resolver);
91
92 let mut conn = factory.new_service(()).await.unwrap();
93 let con = conn.call(Connect::with("10", srv.addr())).await.unwrap();
94 assert_eq!(con.peer_addr().unwrap(), srv.addr());
95 }
96
97 #[cfg(feature = "openssl")]
98 #[actix_rt::test]
test_uri()99 async fn test_uri() {
100 use std::convert::TryFrom;
101
102 let srv = TestServer::with(|| {
103 fn_service(|io: TcpStream| {
104 async {
105 let mut framed = Framed::new(io, BytesCodec);
106 framed.send(Bytes::from_static(b"test")).await?;
107 Ok::<_, io::Error>(())
108 }
109 })
110 });
111
112 let mut conn = actix_connect::default_connector();
113 let addr = http::Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap();
114 let con = conn.call(addr.into()).await.unwrap();
115 assert_eq!(con.peer_addr().unwrap(), srv.addr());
116 }
117
118 #[cfg(feature = "rustls")]
119 #[actix_rt::test]
test_rustls_uri()120 async fn test_rustls_uri() {
121 use std::convert::TryFrom;
122
123 let srv = TestServer::with(|| {
124 fn_service(|io: TcpStream| {
125 async {
126 let mut framed = Framed::new(io, BytesCodec);
127 framed.send(Bytes::from_static(b"test")).await?;
128 Ok::<_, io::Error>(())
129 }
130 })
131 });
132
133 let mut conn = actix_connect::default_connector();
134 let addr = http::Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap();
135 let con = conn.call(addr.into()).await.unwrap();
136 assert_eq!(con.peer_addr().unwrap(), srv.addr());
137 }
138