use super::*;
#[cfg(test)]
mod http_status_tests {
use super::*;
use crate::request::request_group::DownloadOptions;
#[test]
fn classifies_5xx_as_retryable_server_errors() {
assert!(matches!(
classify_metalink_http_status(503),
Aria2Error::Recoverable(RecoverableError::ServerError { code: 503 })
));
}
#[test]
fn classifies_configured_4xx_transients_as_retryable_server_errors() {
for status_code in [408, 429] {
assert!(matches!(
classify_metalink_http_status(status_code),
Aria2Error::Recoverable(RecoverableError::ServerError { code })
if code == status_code
));
}
}
#[test]
fn classifies_not_found_as_resource_not_found() {
assert!(matches!(
classify_metalink_http_status(404),
Aria2Error::Recoverable(RecoverableError::ResourceNotFound)
));
}
#[test]
fn classifies_authentication_statuses_as_http_auth_failures() {
for status_code in [401, 407] {
assert!(matches!(
classify_metalink_http_status(status_code),
Aria2Error::Recoverable(RecoverableError::HttpAuthFailed { message })
if message == format!("authentication failed: HTTP {status_code}")
));
}
}
#[tokio::test]
async fn mirror_not_found_respects_request_group_limit() {
use std::sync::{
Arc,
atomic::{AtomicUsize, Ordering},
};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("404 fixture should bind");
let base_url = format!("http://{}", listener.local_addr().unwrap());
let request_count = Arc::new(AtomicUsize::new(0));
let server_count = Arc::clone(&request_count);
let server = tokio::spawn(async move {
for _ in 0..2 {
let (mut stream, _) = listener.accept().await.expect("404 request");
let mut request = [0u8; 2048];
let _ = stream.read(&mut request).await.expect("read 404 request");
server_count.fetch_add(1, Ordering::SeqCst);
stream
.write_all(
b"HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
)
.await
.expect("write 404 response");
}
});
let output_dir = tempfile::tempdir().expect("output directory");
let xml = format!(
r#"<?xml version="1.0" encoding="UTF-8"?>
<metalink xmlns="urn:ietf:params:xml:ns:metalink">
<file name="payload.bin">
<size>1</size>
<url>{base_url}/first</url>
<url>{base_url}/second</url>
</file>
</metalink>"#
);
let options = DownloadOptions {
dir: Some(output_dir.path().to_string_lossy().into_owned()),
..DownloadOptions::default()
};
let mut command =
MetalinkDownloadCommand::new(GroupId::new(401), xml.as_bytes(), &options, None)
.expect("Metalink command should construct");
command
.group
.recover_mut()
.set_option_snapshot(std::collections::HashMap::from([(
"max-file-not-found".to_string(),
serde_json::json!("2"),
)]));
let error = command
.execute()
.await
.expect_err("second 404 must stop the group");
assert!(matches!(
error,
Aria2Error::Recoverable(RecoverableError::MaxFileNotFound)
));
assert_eq!(request_count.load(Ordering::SeqCst), 2);
server.await.expect("404 fixture should finish");
}
#[tokio::test]
async fn mirror_not_found_zero_does_not_fail_over_to_next_mirror() {
use std::sync::{
Arc,
atomic::{AtomicUsize, Ordering},
};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("404 fixture should bind");
let base_url = format!("http://{}", listener.local_addr().unwrap());
let request_count = Arc::new(AtomicUsize::new(0));
let server_count = Arc::clone(&request_count);
let server = tokio::spawn(async move {
let (mut stream, _) = listener.accept().await.expect("first 404 request");
let mut request = [0u8; 2048];
let _ = stream.read(&mut request).await.expect("read first request");
server_count.fetch_add(1, Ordering::SeqCst);
stream
.write_all(
b"HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
)
.await
.expect("write first 404 response");
if let Ok(Ok((mut stream, _))) =
tokio::time::timeout(std::time::Duration::from_millis(500), listener.accept()).await
{
let _ = stream
.read(&mut request)
.await
.expect("read second request");
server_count.fetch_add(1, Ordering::SeqCst);
stream
.write_all(
b"HTTP/1.1 200 OK\r\nContent-Length: 1\r\nConnection: close\r\n\r\nx",
)
.await
.expect("write second response");
}
});
let output_dir = tempfile::tempdir().expect("output directory");
let xml = format!(
r#"<?xml version="1.0" encoding="UTF-8"?>
<metalink xmlns="urn:ietf:params:xml:ns:metalink">
<file name="payload.bin">
<size>1</size>
<url>{base_url}/first</url>
<url>{base_url}/second</url>
</file>
</metalink>"#
);
let options = DownloadOptions {
dir: Some(output_dir.path().to_string_lossy().into_owned()),
..DownloadOptions::default()
};
let mut command =
MetalinkDownloadCommand::new(GroupId::new(402), xml.as_bytes(), &options, None)
.expect("Metalink command should construct");
command
.group
.recover_mut()
.set_option_snapshot(std::collections::HashMap::from([(
"max-file-not-found".to_string(),
serde_json::json!("0"),
)]));
let output_path = command.output_path.clone();
let error = command
.execute()
.await
.expect_err("max-file-not-found=0 must stop after the first 404");
assert!(matches!(
error,
Aria2Error::Recoverable(RecoverableError::ResourceNotFound)
));
assert_eq!(request_count.load(Ordering::SeqCst), 1);
assert!(!output_path.exists());
tokio::time::timeout(std::time::Duration::from_secs(2), server)
.await
.expect("404 fixture should finish")
.expect("404 fixture task should succeed");
}
#[tokio::test]
async fn mirror_504_retries_before_completing() {
use std::sync::{
Arc,
atomic::{AtomicUsize, Ordering},
};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("504 fixture should bind");
let url = format!("http://{}/payload", listener.local_addr().unwrap());
let request_count = Arc::new(AtomicUsize::new(0));
let server_count = Arc::clone(&request_count);
let server = tokio::spawn(async move {
for attempt in 0..2 {
let (mut stream, _) = listener.accept().await.expect("mirror request");
let mut request = [0u8; 2048];
let _ = stream
.read(&mut request)
.await
.expect("read mirror request");
server_count.fetch_add(1, Ordering::SeqCst);
if attempt == 0 {
stream
.write_all(
b"HTTP/1.1 504 Gateway Timeout\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
)
.await
.expect("write 504 response");
} else {
stream
.write_all(
b"HTTP/1.1 200 OK\r\nContent-Length: 1\r\nConnection: close\r\n\r\nx",
)
.await
.expect("write success response");
}
}
});
let output_dir = tempfile::tempdir_in("../target").expect("output directory");
let xml = format!(
r#"<?xml version="1.0"?>
<metalink xmlns="urn:ietf:params:xml:ns:metalink">
<file name="payload.bin">
<size>1</size>
<url>{url}</url>
</file>
</metalink>"#
);
let options = DownloadOptions {
dir: Some(output_dir.path().to_string_lossy().into_owned()),
max_retries: 2,
retry_wait: 0,
..DownloadOptions::default()
};
let mut command =
MetalinkDownloadCommand::new(GroupId::new(403), xml.as_bytes(), &options, None)
.expect("Metalink command should construct");
command.execute().await.expect("504 retry should complete");
assert_eq!(request_count.load(Ordering::SeqCst), 2);
assert_eq!(tokio::fs::read(command.output_path()).await.unwrap(), b"x");
server.await.expect("504 fixture should finish");
}
#[tokio::test]
async fn ftp_mirror_uses_the_ftp_protocol_adapter() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("FTP proxy fixture should bind");
let proxy_address = listener.local_addr().expect("FTP proxy address");
let server = tokio::spawn(async move {
let (mut stream, _) = listener.accept().await.expect("FTP mirror request");
let mut request = [0u8; 4096];
let length = stream.read(&mut request).await.expect("read proxy request");
let request = String::from_utf8_lossy(&request[..length]).into_owned();
stream
.write_all(
b"HTTP/1.1 200 OK\r\nContent-Length: 7\r\nConnection: close\r\n\r\npayload",
)
.await
.expect("write FTP proxy payload");
request
});
let output_dir = tempfile::tempdir_in("../target").expect("output directory");
let xml = br#"<?xml version="1.0"?>
<metalink xmlns="urn:ietf:params:xml:ns:metalink">
<file name="payload.bin"><size>7</size><url>ftp://127.0.0.1:21/payload.bin</url></file>
</metalink>"#;
let options = DownloadOptions {
dir: Some(output_dir.path().to_string_lossy().into_owned()),
ftp_proxy: Some(format!("http://{proxy_address}")),
proxy_method: "get".to_string(),
max_retries: 1,
..DownloadOptions::default()
};
let mut command = MetalinkDownloadCommand::new(GroupId::new(404), xml, &options, None)
.expect("Metalink command should construct");
command
.execute()
.await
.expect("FTP mirror should download through the FTP adapter");
assert_eq!(
tokio::fs::read(command.output_path()).await.unwrap(),
b"payload"
);
let request = server.await.expect("FTP proxy fixture should finish");
assert!(
request.starts_with("GET ftp://anonymous@127.0.0.1/payload.bin "),
"unexpected FTP proxy request: {request:?}"
);
}
#[cfg(feature = "bittorrent")]
#[tokio::test]
async fn torrent_metaurl_504_retries_before_returning_metadata() {
use std::sync::{
Arc,
atomic::{AtomicUsize, Ordering},
};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("torrent metaurl fixture should bind");
let url = format!("http://{}/payload.torrent", listener.local_addr().unwrap());
let request_count = Arc::new(AtomicUsize::new(0));
let server_count = Arc::clone(&request_count);
let server = tokio::spawn(async move {
for attempt in 0..2 {
let (mut stream, _) = listener.accept().await.expect("metadata request");
let mut request = [0u8; 2048];
let _ = stream
.read(&mut request)
.await
.expect("read metadata request");
server_count.fetch_add(1, Ordering::SeqCst);
if attempt == 0 {
stream
.write_all(
b"HTTP/1.1 504 Gateway Timeout\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
)
.await
.expect("write 504 response");
} else {
stream
.write_all(
b"HTTP/1.1 200 OK\r\nContent-Length: 1\r\nConnection: close\r\n\r\nx",
)
.await
.expect("write metadata response");
}
}
});
let options = DownloadOptions {
max_retries: 2,
retry_wait: 0,
..DownloadOptions::default()
};
let mut command = MetalinkDownloadCommand::new(
GroupId::new(404),
br#"<?xml version="1.0"?><metalink xmlns="urn:ietf:params:xml:ns:metalink"><file name="payload.bin"><url>http://127.0.0.1/unused</url></file></metalink>"#,
&options,
None,
)
.expect("Metalink command should construct");
let metadata = command
.download_metadata_url_with_retry(&url)
.await
.expect("504 retry should return metadata");
assert_eq!(metadata, b"x");
assert_eq!(request_count.load(Ordering::SeqCst), 2);
server.await.expect("torrent metaurl fixture should finish");
}
#[cfg(feature = "bittorrent")]
#[tokio::test]
async fn slow_torrent_metadata_read_observes_pause() {
use std::sync::Arc;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
use tokio::sync::oneshot;
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("metadata fixture should bind");
let url = format!("http://{}/payload.torrent", listener.local_addr().unwrap());
let (headers_tx, headers_rx) = oneshot::channel();
let server = tokio::spawn(async move {
let (mut stream, _) = listener.accept().await.expect("metadata request");
let mut request = [0u8; 2048];
let _ = stream
.read(&mut request)
.await
.expect("read metadata request");
stream
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 4\r\nConnection: close\r\n\r\n")
.await
.expect("write metadata headers");
let _ = headers_tx.send(());
tokio::time::sleep(Duration::from_secs(2)).await;
});
let options = DownloadOptions::default();
let command = MetalinkDownloadCommand::new(
GroupId::new(402),
br#"<?xml version="1.0"?><metalink xmlns="urn:ietf:params:xml:ns:metalink"><file name="payload.bin"><size>4</size><url>http://127.0.0.1/unused</url></file></metalink>"#,
&options,
None,
)
.expect("Metalink command should construct");
let group = Arc::clone(&command.group);
let command_task = tokio::spawn(async move { command.download_metadata_url(&url).await });
headers_rx.await.expect("metadata headers should be sent");
group.recover_mut().pause().expect("pause should succeed");
let result = tokio::time::timeout(Duration::from_secs(1), command_task)
.await
.expect("metadata read should stop promptly after pause")
.expect("metadata task should not panic")
.expect_err("paused metadata read must return an error");
assert!(matches!(
result,
Aria2Error::DownloadFailed(message) if message == "Download paused"
));
server.abort();
}
}