openharmony/commonlibrary_rust_ylong_http
1
0
Fork 0
mirror of https://github.com/openharmony/commonlibrary_rust_ylong_http.git synced 2026-07-19 16:33:37 -04:00
Code Issues Packages Projects Releases Wiki Activity

remove network limit ut

Browse Source 
Signed-off-by: Tiga Ultraman <liaoxude@huawei.com>
This commit is contained in:
Tiga Ultraman
2024-11-06 11:20:45 +08:00
parent d92fc4cc93
commit 69eabe5539
2 changed files with 0 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ylong_http_client/src/async_impl/dns/happy_eyeballs.rs
-108
View File
@@ -247,111 +247,3 @@ fn connect(
}
}
}
#[cfg(all(test, feature = "ylong_base"))]
mod ut_dns_happy_eyeballs {
use std::io;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, TcpListener};
use std::time::{Duration, Instant};
use crate::async_impl::dns::{EyeBallConfig, HappyEyeballs};
#[test]
fn ut_happy_eyeballs_connect() {
let server_v4_listener = TcpListener::bind("127.0.0.1:0").expect("bind local v4 error");
let server_v4_addr = server_v4_listener
.local_addr()
.expect("get local v4 socket addr error");
// use dual-stack mode.
let _server_v6_listener = TcpListener::bind(format!("[::1]:{}", server_v4_addr.port()))
.expect("bind local v6 error");
let local_v4_addr = IpAddr::from(Ipv4Addr::new(127, 0, 0, 1));
let local_v6_addr = IpAddr::from(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));
let invalid_v4_addr = IpAddr::from(Ipv4Addr::new(127, 0, 0, 2));
let invalid_v6_addr = IpAddr::from(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 2));
let internet_v4_addr = IpAddr::from(Ipv4Addr::new(198, 18, 0, 25));
let default_timeout = Duration::default();
let invalid_v4_timeout = test_addrs(invalid_v4_addr).1;
let invalid_v6_timeout = test_addrs(invalid_v6_addr).1;
let local_v6_timeout = test_addrs(local_v6_addr).1;
let delay_time = Duration::from_millis(300);
let test_cases = &[
(&[local_v4_addr][..], 4, default_timeout),
(&[local_v6_addr][..], 6, default_timeout),
(&[local_v4_addr, local_v6_addr][..], 4, default_timeout),
(&[local_v6_addr, local_v4_addr][..], 6, default_timeout),
(&[invalid_v4_addr, local_v4_addr][..], 4, invalid_v4_timeout),
(&[invalid_v6_addr, local_v6_addr][..], 6, invalid_v6_timeout),
(
&[invalid_v4_addr, local_v4_addr, local_v6_addr][..],
4,
invalid_v4_timeout,
),
(
&[invalid_v6_addr, local_v6_addr, local_v4_addr][..],
6,
invalid_v6_timeout,
),
(
&[internet_v4_addr, local_v4_addr, local_v6_addr][..],
6,
delay_time + local_v6_timeout,
),
(
&[internet_v4_addr, invalid_v6_addr, local_v6_addr][..],
6,
delay_time + invalid_v6_timeout + local_v6_timeout,
),
];
for &(hosts, family, timeout) in test_cases {
let (start, stream) = ylong_runtime::block_on(async move {
let addrs = hosts
.iter()
.map(|ip| (*ip, server_v4_addr.port()).into())
.collect();
let config = EyeBallConfig::new(None, Some(delay_time));
let happy_eyeballs = HappyEyeballs::new(addrs, config);
let start = Instant::now();
Ok::<_, io::Error>((start, happy_eyeballs.connect().await?))
})
.unwrap();
let stream_addr_family = if stream.peer_addr().unwrap().is_ipv4() {
4
} else {
6
};
let duration = start.elapsed();
let min_duration = if timeout >= Duration::from_millis(150) {
timeout - Duration::from_millis(150)
} else {
Duration::default()
};
let max_duration = timeout + Duration::from_millis(150);
assert_eq!(stream_addr_family, family);
assert!(duration >= min_duration);
assert!(duration <= max_duration);
}
fn test_addrs(addr: IpAddr) -> (bool, Duration) {
let start = Instant::now();
let reachable = match std::net::TcpStream::connect_timeout(
&SocketAddr::from((addr, 80)),
Duration::from_secs(1),
) {
Ok(_) => true,
Err(err) => err.kind() == io::ErrorKind::TimedOut,
};
let duration = start.elapsed();
(reachable, duration)
}
}
}
ylong_http_client/src/async_impl/dns/resolver.rs
-60
View File
@@ -102,63 +102,3 @@ impl Resolver for DefaultDnsResolver {
Box::pin(DefaultDnsFuture { inner: blocking })
}
}
#[cfg(test)]
mod ut_dns_resolver {
use crate::async_impl::{DefaultDnsResolver, Resolver};
/// UT test cases for `FrameDecoder::decode`.
///
/// # Brief
///
/// Test a simple complete DATA frame.
/// 1. Creates a `FrameDecoder`.
/// 2. Calls its `FrameDecoder::decode` method.
/// 3. Checks the results.
#[test]
#[cfg(feature = "ylong_base")]
fn ut_resolver_std_dns_resolver_resolve() {
ylong_runtime::block_on(async move {
let resolver = DefaultDnsResolver {};
let sockets = resolver
.resolve("www.baidu.com:80")
.await
.expect("dns resolver resolve domain occurs err");
let mut size = 0;
for _socket in sockets.into_iter() {
size += 1;
}
assert!(size > 0);
});
}
/// UT test cases for `FrameDecoder::decode`.
///
/// # Brief
///
/// Test a simple complete DATA frame.
/// 1. Creates a `FrameDecoder`.
/// 2. Calls its `FrameDecoder::decode` method.
/// 3. Checks the results.
#[test]
#[cfg(feature = "tokio_base")]
fn ut_resolver_std_dns_resolver_resolve() {
let runtime = tokio::runtime::Builder::new_multi_thread()
.worker_threads(1)
.enable_all()
.build()
.expect("Build runtime failed.");
runtime.block_on(async move {
let resolver = DefaultDnsResolver {};
let sockets = resolver
.resolve("www.baidu.com:80")
.await
.expect("dns resolver resolve domain occurs err");
let mut size = 0;
for _socket in sockets.into_iter() {
size += 1;
}
assert!(size > 0);
});
}
}