use std::time::Duration;
use super::capabilities::ServerCapabilities;
use super::control::read_response_impl;
use super::parsing::{
days_from_civil, extract_directory_part, extract_file_part, parse_epsv_response,
parse_mdtm_timestamp, parse_pasv_response, percent_decode,
};
use super::{FtpNegotiationConfig, FtpTransferType};
use crate::ftp::connection::types::FtpMode;
#[tokio::test]
async fn test_read_response_preserves_multiline_response() {
let response = b"211-Features:\r\n UTF8\r\n211 End\r\n".to_vec();
let mut reader = tokio::io::BufReader::new(std::io::Cursor::new(response));
let (code, message) = read_response_impl(&mut reader, Duration::from_secs(1))
.await
.expect("multiline FTP response should parse");
assert_eq!(code, 211);
assert_eq!(message, "Features:\n UTF8\nEnd");
let mut capabilities = ServerCapabilities::new();
capabilities.parse_feat_response(&message);
assert!(capabilities.utf8);
}
#[tokio::test]
async fn test_read_response_rejects_oversized_response() {
let response = format!("211-{}\r\n211 End\r\n", "x".repeat(65_536));
let mut reader = tokio::io::BufReader::new(std::io::Cursor::new(response.into_bytes()));
let error = read_response_impl(&mut reader, Duration::from_secs(1))
.await
.expect_err("oversized FTP response must be rejected");
assert!(error.to_string().contains("Max FTP recv buffer reached"));
}
#[test]
fn test_percent_decode_basic() {
assert_eq!(percent_decode("hello"), "hello");
assert_eq!(percent_decode("hello%20world"), "hello world");
assert_eq!(percent_decode("file%2Etxt"), "file.txt");
}
#[test]
fn test_percent_decode_utf8() {
assert_eq!(percent_decode("%E6%96%87%E4%BB%B6"), "文件");
}
#[test]
fn test_percent_decode_invalid() {
assert_eq!(percent_decode("test%ZZ"), "test%ZZ");
}
#[test]
fn test_percent_decode_mixed() {
assert_eq!(
percent_decode("/pub/my%20dir/file.txt"),
"/pub/my dir/file.txt"
);
}
#[test]
fn test_extract_directory_part() {
assert_eq!(
extract_directory_part("/pub/linux/file.tar.gz"),
"/pub/linux"
);
assert_eq!(extract_directory_part("/file.txt"), "");
assert_eq!(extract_directory_part("/"), "");
assert_eq!(extract_directory_part(""), "");
assert_eq!(
extract_directory_part("/path/to/dir/file.txt"),
"/path/to/dir"
);
}
#[test]
fn test_extract_directory_part_percent_decoded() {
assert_eq!(
extract_directory_part("/pub/my%20dir/file.txt"),
"/pub/my dir"
);
assert_eq!(
extract_directory_part("/path/%2E%2E/hidden/file.txt"),
"/path/../hidden"
);
}
#[test]
fn test_extract_file_part() {
assert_eq!(extract_file_part("/pub/linux/file.tar.gz"), "file.tar.gz");
assert_eq!(extract_file_part("/file.txt"), "file.txt");
assert_eq!(extract_file_part("/"), "");
assert_eq!(extract_file_part(""), "");
}
#[test]
fn test_extract_file_part_percent_decoded() {
assert_eq!(
extract_file_part("/pub/linux/my%20file.tar.gz"),
"my file.tar.gz"
);
assert_eq!(extract_file_part("/dir/file%2Etxt"), "file.txt");
}
#[test]
fn test_parse_mdtm_timestamp_valid() {
let ts = parse_mdtm_timestamp("20240115103000").unwrap();
let duration = ts.duration_since(std::time::UNIX_EPOCH).unwrap();
assert_eq!(duration.as_secs(), 1705314600);
}
#[test]
fn test_parse_mdtm_timestamp_invalid() {
assert!(parse_mdtm_timestamp("").is_none());
assert!(parse_mdtm_timestamp("2024").is_none());
assert!(parse_mdtm_timestamp("20241301120000").is_none()); assert!(parse_mdtm_timestamp("20240132120000").is_none()); }
#[test]
fn test_parse_pasv_response_standard() {
let resp = "227 Entering Passive Mode (192,168,1,100,195,123)";
let result = parse_pasv_response(resp).unwrap();
assert_eq!(result.0, "192.168.1.100");
assert_eq!(result.1, 195 * 256 + 123);
}
#[test]
fn test_parse_pasv_response_invalid() {
assert!(parse_pasv_response("no parentheses").is_none());
assert!(parse_pasv_response("(1,2,3)").is_none()); }
#[test]
fn test_parse_epsv_response_standard() {
let resp = "229 Entering Extended Passive Mode (|||50001|)";
let result = parse_epsv_response(resp).unwrap();
assert_eq!(result, 50001);
}
#[test]
fn test_parse_epsv_response_minimal() {
let resp = "|||60000|";
let result = parse_epsv_response(resp).unwrap();
assert_eq!(result, 60000);
}
#[test]
fn test_days_from_civil_epoch() {
assert_eq!(days_from_civil(1970, 1, 1), Some(0));
assert_eq!(days_from_civil(1970, 1, 2), Some(1));
assert_eq!(days_from_civil(2000, 1, 1), Some(10957));
}
#[test]
fn test_cwd_traversal_splitting() {
let path = "/pub/linux";
let dirs: Vec<&str> = path.split('/').filter(|c| !c.is_empty()).collect();
assert_eq!(dirs, vec!["pub", "linux"]);
}
#[test]
fn test_ftp_negotiation_config_defaults() {
let config = FtpNegotiationConfig {
host: "example.com".to_string(),
port: 21,
username: "anonymous".to_string(),
password: "aria2@".to_string(),
remote_path: "/pub/file.txt".to_string(),
mode: FtpMode::Passive,
transfer_type: FtpTransferType::Binary,
resume_offset: 0,
remote_time: false,
connect_timeout: Duration::from_secs(30),
command_timeout: Duration::from_secs(30),
is_pooled: false,
pooled_base_working_dir: None,
data_proxy: None,
};
assert_eq!(config.host, "example.com");
assert_eq!(config.port, 21);
assert!(!config.is_pooled);
}
#[test]
fn test_server_capabilities_default() {
let caps = ServerCapabilities::new();
assert!(!caps.utf8);
assert!(!caps.mlst_mlsd);
assert!(!caps.size);
assert!(!caps.mdtm);
assert!(!caps.epsv);
assert!(!caps.eprt);
assert!(!caps.tvfs);
assert!(caps.syst.is_none());
}
#[test]
fn test_feat_parse_full() {
let response = "\
211-Features:
UTF8
MLST type*;size*;modify*;
SIZE
MDTM
EPSV
EPRT
TVFS
211 End";
let mut caps = ServerCapabilities::new();
caps.parse_feat_response(response);
assert!(caps.utf8);
assert!(caps.mlst_mlsd);
assert!(caps.size);
assert!(caps.mdtm);
assert!(caps.epsv);
assert!(caps.eprt);
assert!(caps.tvfs);
}
#[test]
fn test_feat_parse_minimal() {
let response = "\
211-Features:
UTF8
211 End";
let mut caps = ServerCapabilities::new();
caps.parse_feat_response(response);
assert!(caps.utf8);
assert!(!caps.mlst_mlsd);
assert!(!caps.size);
}
#[test]
fn test_feat_parse_case_insensitive() {
let response = "\
211-Features:
utf8
mlst type*;size*;
211 End";
let mut caps = ServerCapabilities::new();
caps.parse_feat_response(response);
assert!(caps.utf8);
assert!(caps.mlst_mlsd);
}
#[test]
fn test_feat_parse_empty() {
let response = "211 End";
let mut caps = ServerCapabilities::new();
caps.parse_feat_response(response);
assert!(!caps.utf8);
assert!(!caps.mlst_mlsd);
}
#[test]
fn test_feat_mlsd_as_separate_feature() {
let response = "\
211-Features:
MLST type*;size*;
MLSD
211 End";
let mut caps = ServerCapabilities::new();
caps.parse_feat_response(response);
assert!(caps.mlst_mlsd);
}