1 #![cfg(feature = "connect")]
2
3 use std::{
4 io,
5 net::{IpAddr, Ipv4Addr},
6 };
7
8 use actix_codec::{BytesCodec, Framed};
9 use actix_rt::net::TcpStream;
10 use actix_server::TestServer;
11 use actix_service::{fn_service, Service, ServiceFactory};
12 use bytes::Bytes;
13 use futures_util::sink::SinkExt;
14
15 use actix_tls::connect::{self as actix_connect, Connect};
16
17 #[cfg(feature = "openssl")]
18 #[actix_rt::test]
test_string()19 async fn test_string() {
20 let srv = TestServer::with(|| {
21 fn_service(|io: TcpStream| async {
22 let mut framed = Framed::new(io, BytesCodec);
23 framed.send(Bytes::from_static(b"test")).await?;
24 Ok::<_, io::Error>(())
25 })
26 });
27
28 let conn = actix_connect::default_connector();
29 let addr = format!("localhost:{}", srv.port());
30 let con = conn.call(addr.into()).await.unwrap();
31 assert_eq!(con.peer_addr().unwrap(), srv.addr());
32 }
33
34 #[cfg(feature = "rustls")]
35 #[actix_rt::test]
test_rustls_string()36 async fn test_rustls_string() {
37 let srv = TestServer::with(|| {
38 fn_service(|io: TcpStream| async {
39 let mut framed = Framed::new(io, BytesCodec);
40 framed.send(Bytes::from_static(b"test")).await?;
41 Ok::<_, io::Error>(())
42 })
43 });
44
45 let 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| async {
55 let mut framed = Framed::new(io, BytesCodec);
56 framed.send(Bytes::from_static(b"test")).await?;
57 Ok::<_, io::Error>(())
58 })
59 });
60
61 let conn = actix_connect::default_connector();
62
63 let con = conn
64 .call(Connect::with_addr("10", srv.addr()))
65 .await
66 .unwrap();
67 assert_eq!(con.peer_addr().unwrap(), srv.addr());
68
69 let connect = Connect::new(srv.host().to_owned());
70
71 let conn = actix_connect::default_connector();
72 let con = conn.call(connect).await;
73 assert!(con.is_err());
74 }
75
76 #[actix_rt::test]
test_new_service()77 async fn test_new_service() {
78 let srv = TestServer::with(|| {
79 fn_service(|io: TcpStream| 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 let factory = actix_connect::default_connector_factory();
87
88 let conn = factory.new_service(()).await.unwrap();
89 let con = conn
90 .call(Connect::with_addr("10", srv.addr()))
91 .await
92 .unwrap();
93 assert_eq!(con.peer_addr().unwrap(), srv.addr());
94 }
95
96 #[cfg(all(feature = "openssl", feature = "uri"))]
97 #[actix_rt::test]
test_openssl_uri()98 async fn test_openssl_uri() {
99 use std::convert::TryFrom;
100
101 let srv = TestServer::with(|| {
102 fn_service(|io: TcpStream| async {
103 let mut framed = Framed::new(io, BytesCodec);
104 framed.send(Bytes::from_static(b"test")).await?;
105 Ok::<_, io::Error>(())
106 })
107 });
108
109 let conn = actix_connect::default_connector();
110 let addr = http::Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap();
111 let con = conn.call(addr.into()).await.unwrap();
112 assert_eq!(con.peer_addr().unwrap(), srv.addr());
113 }
114
115 #[cfg(all(feature = "rustls", feature = "uri"))]
116 #[actix_rt::test]
test_rustls_uri()117 async fn test_rustls_uri() {
118 use std::convert::TryFrom;
119
120 let srv = TestServer::with(|| {
121 fn_service(|io: TcpStream| async {
122 let mut framed = Framed::new(io, BytesCodec);
123 framed.send(Bytes::from_static(b"test")).await?;
124 Ok::<_, io::Error>(())
125 })
126 });
127
128 let conn = actix_connect::default_connector();
129 let addr = http::Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap();
130 let con = conn.call(addr.into()).await.unwrap();
131 assert_eq!(con.peer_addr().unwrap(), srv.addr());
132 }
133
134 #[actix_rt::test]
test_local_addr()135 async fn test_local_addr() {
136 let srv = TestServer::with(|| {
137 fn_service(|io: TcpStream| async {
138 let mut framed = Framed::new(io, BytesCodec);
139 framed.send(Bytes::from_static(b"test")).await?;
140 Ok::<_, io::Error>(())
141 })
142 });
143
144 let conn = actix_connect::default_connector();
145 let local = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 3));
146
147 let (con, _) = conn
148 .call(Connect::with_addr("10", srv.addr()).set_local_addr(local))
149 .await
150 .unwrap()
151 .into_parts();
152
153 assert_eq!(con.local_addr().unwrap().ip(), local)
154 }
155