Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

test: keep failed proxy DNS outside curl

ldm0f220ffc53a05
diff --git a/moli-curl/src/runtime/tests.rs b/moli-curl/src/runtime/tests.rs
index 3152f3eed..4a993ef97 100644
--- a/moli-curl/src/runtime/tests.rs
+++ b/moli-curl/src/runtime/tests.rs
@@ -1,18 +1,38 @@
use std::{
io::{Read, Write},
net::TcpListener,
- time::Duration,
+ time::{Duration, Instant},
};
use super::*;
use crate::{CurlDnsResolution, CurlMultiJob};
use curl::easy::Easy2;
+use moli_dns_resolver::DnsTarget;
#[derive(Debug)]
struct TestHandler;
impl Handler for TestHandler {}
+fn assert_listener_stays_idle(listener: &TcpListener) {
+ listener
+ .set_nonblocking(true)
+ .expect("test listener should become nonblocking");
+ let deadline = Instant::now() + Duration::from_millis(200);
+ loop {
+ match listener.accept() {
+ Ok(_) => panic!("curl connected after shared proxy DNS failed"),
+ Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {
+ if Instant::now() >= deadline {
+ return;
+ }
+ thread::sleep(Duration::from_millis(5));
+ }
+ Err(error) => panic!("failed to inspect test listener: {error}"),
+ }
+ }
+}
+
#[test]
fn submitted_identity_reaches_the_matching_runtime_completion() {
let listener = TcpListener::bind(("127.0.0.1", 0))
@@ -71,6 +91,54 @@ fn submitted_identity_reaches_the_matching_runtime_completion() {
server.join().expect("test HTTP server should finish");
}
+#[test]
+fn shared_proxy_dns_failure_never_starts_the_http_transfer() {
+ let listener = TcpListener::bind(("127.0.0.1", 0))
+ .expect("test proxy listener should bind to a local port");
+ let proxy_address = listener
+ .local_addr()
+ .expect("test proxy listener should have an address");
+ let (runtime, completion_rx) = CurlMultiRuntime::new(CurlMultiRuntimeConfig {
+ poll_interval: Duration::from_millis(5),
+ ..CurlMultiRuntimeConfig::default()
+ })
+ .expect("test curl runtime should start");
+ let mut easy = Easy2::new(TestHandler);
+ easy.url("http://request-target.invalid/proxy-dns-failure")
+ .unwrap();
+ easy.proxy(&format!("http://{proxy_address}")).unwrap();
+ easy.noproxy("").unwrap();
+
+ runtime
+ .http_sender()
+ .submit(CurlMultiJob {
+ easy,
+ context: (),
+ origin: None,
+ deadline: Some(Instant::now() + Duration::from_secs(5)),
+ dns_resolution: CurlDnsResolution::resolve_endpoint(
+ DnsTarget::new("proxy.invalid", proxy_address.port()),
+ Vec::new(),
+ ),
+ priority: 1,
+ label: "proxy-dns-failure".to_owned(),
+ })
+ .expect("test curl transfer should be accepted");
+
+ let completion = completion_rx
+ .recv_timeout(Duration::from_secs(5))
+ .expect("shared DNS failure should complete the transfer");
+ let error = completion
+ .result
+ .expect_err("reserved proxy domain must fail in Moli DNS");
+ assert!(
+ error.to_string().contains("reserved .invalid domain"),
+ "unexpected DNS error: {error:#}"
+ );
+ assert_listener_stays_idle(&listener);
+ runtime.shutdown();
+}
+
#[test]
fn http_sender_does_not_keep_owner_alive_and_returns_rejected_job() {
let (runtime, completed) =
diff --git a/moli-curl/src/websocket/tests.rs b/moli-curl/src/websocket/tests.rs
index 8534a349b..d2ce95e78 100644
--- a/moli-curl/src/websocket/tests.rs
+++ b/moli-curl/src/websocket/tests.rs
@@ -3,6 +3,7 @@ use std::{
net::{TcpListener, TcpStream},
sync::{Arc, atomic::Ordering},
thread,
+ time::Instant,
};
use tokio::{sync::oneshot, time::timeout};
@@ -110,6 +111,37 @@ async fn strict_connector_checks_shared_websocket_dns_before_connecting() {
}
}
+#[tokio::test]
+async fn shared_proxy_dns_failure_never_starts_the_websocket_transfer() {
+ let listener = TcpListener::bind(("127.0.0.1", 0))
+ .expect("test proxy listener should bind to a local port");
+ let proxy_address = listener
+ .local_addr()
+ .expect("test proxy listener should have an address");
+ let runtime = CurlWebSocketRuntime::new().unwrap();
+ let mut request =
+ CurlWebSocketRequest::new("ws://websocket-target.invalid/proxy-dns-failure".to_owned());
+ request.proxy = Some(format!("http://{proxy_address}"));
+ request.handshake_timeout = DEADLINE;
+ request.dns_resolution = CurlDnsResolution::resolve_endpoint(
+ DnsTarget::new("proxy.invalid", proxy_address.port()),
+ Vec::new(),
+ );
+
+ let mut connection = runtime.connect(request).unwrap();
+ let event = timeout(DEADLINE, connection.recv())
+ .await
+ .expect("WebSocket DNS failure deadline")
+ .expect("WebSocket DNS failure event");
+ match event {
+ CurlWebSocketEvent::Closed { result: Err(error) } => {
+ assert!(error.contains("reserved .invalid domain"), "{error}")
+ }
+ unexpected => panic!("expected a DNS failure, got {unexpected:?}"),
+ }
+ assert_listener_stays_idle(&listener);
+}
+
fn server(handler: impl FnOnce(TcpStream) + Send + 'static) -> (String, thread::JoinHandle<()>) {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let url = format!("ws://{}/native", listener.local_addr().unwrap());
@@ -133,6 +165,25 @@ fn read_request(stream: &mut TcpStream) -> String {
String::from_utf8(request).unwrap()
}
+fn assert_listener_stays_idle(listener: &TcpListener) {
+ listener
+ .set_nonblocking(true)
+ .expect("test listener should become nonblocking");
+ let deadline = Instant::now() + Duration::from_millis(200);
+ loop {
+ match listener.accept() {
+ Ok(_) => panic!("curl connected after shared proxy DNS failed"),
+ Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {
+ if Instant::now() >= deadline {
+ return;
+ }
+ thread::sleep(Duration::from_millis(5));
+ }
+ Err(error) => panic!("failed to inspect test listener: {error}"),
+ }
+ }
+}
+
fn upgrade(stream: &mut TcpStream, tail: &[u8]) {
let request = read_request(stream);
let key = request