use std::io;
use super::wire::{
read_raw, read_string, read_u32, read_u64, write_string, write_string_raw, write_u32, write_u64,
};
use super::*;
#[test]
fn test_init_roundtrip() {
let pkt = SftpPacket::Init { version: 3 };
let encoded = pkt.encode().unwrap();
let (decoded, consumed) = SftpPacket::decode(&encoded).unwrap();
assert_eq!(consumed, encoded.len());
assert_eq!(decoded, pkt);
}
#[test]
fn test_version_with_extensions_roundtrip() {
let pkt = SftpPacket::Version {
version: 3,
extensions: vec![
("hardlink@openssh.com".to_string(), "1".to_string()),
("fsync@openssh.com".to_string(), "1".to_string()),
],
};
let encoded = pkt.encode().unwrap();
let (decoded, consumed) = SftpPacket::decode(&encoded).unwrap();
assert_eq!(consumed, encoded.len());
assert_eq!(decoded, pkt);
}
#[test]
fn test_open_roundtrip() {
let pkt = SftpPacket::Open {
request_id: 42,
filename: "/tmp/test.dat".to_string(),
flags: SSH_FXF_READ | SSH_FXF_WRITE,
attrs: SftpFileAttrs::default(),
};
let encoded = pkt.encode().unwrap();
let (decoded, consumed) = SftpPacket::decode(&encoded).unwrap();
assert_eq!(consumed, encoded.len());
assert_eq!(decoded, pkt);
}
#[test]
fn test_status_roundtrip() {
let pkt = SftpPacket::Status {
request_id: 1,
code: SSH_FX_OK,
message: "OK".to_string(),
language: "en".to_string(),
};
let encoded = pkt.encode().unwrap();
let (decoded, consumed) = SftpPacket::decode(&encoded).unwrap();
assert_eq!(consumed, encoded.len());
assert_eq!(decoded, pkt);
}
#[test]
fn test_handle_roundtrip() {
let pkt = SftpPacket::Handle {
request_id: 5,
handle: vec![0x01, 0x02, 0x03],
};
let encoded = pkt.encode().unwrap();
let (decoded, consumed) = SftpPacket::decode(&encoded).unwrap();
assert_eq!(consumed, encoded.len());
assert_eq!(decoded, pkt);
}
#[test]
fn test_data_roundtrip() {
let pkt = SftpPacket::Data {
request_id: 10,
data: b"hello world".to_vec(),
};
let encoded = pkt.encode().unwrap();
let (decoded, consumed) = SftpPacket::decode(&encoded).unwrap();
assert_eq!(consumed, encoded.len());
assert_eq!(decoded, pkt);
}
#[test]
fn test_name_roundtrip() {
let pkt = SftpPacket::Name {
request_id: 20,
entries: vec![SftpNameEntry {
filename: "file1.txt".to_string(),
longname: "-rw-r--r-- 1 user group 1234 Jan 1 00:00 file1.txt".to_string(),
attrs: SftpFileAttrs::full(1234, 1000, 1000, 0o100644, 1700000000, 1700000100),
}],
};
let encoded = pkt.encode().unwrap();
let (decoded, consumed) = SftpPacket::decode(&encoded).unwrap();
assert_eq!(consumed, encoded.len());
assert_eq!(decoded, pkt);
}
#[test]
fn test_attrs_roundtrip() {
let pkt = SftpPacket::Attrs {
request_id: 30,
attrs: SftpFileAttrs::full(4096, 0, 0, 0o040755, 1700000000, 1700000100),
};
let encoded = pkt.encode().unwrap();
let (decoded, consumed) = SftpPacket::decode(&encoded).unwrap();
assert_eq!(consumed, encoded.len());
assert_eq!(decoded, pkt);
}
#[test]
fn test_decode_incomplete_returns_error() {
let buf = [0u8; 3]; let result = SftpPacket::decode(&buf);
assert!(result.is_err());
}
#[test]
fn test_decode_partial_payload_returns_error() {
let pkt = SftpPacket::Init { version: 3 };
let encoded = pkt.encode().unwrap();
let result = SftpPacket::decode(&encoded[..5]); assert!(result.is_err());
}
#[test]
fn malformed_packet_trailing_payload_is_rejected() {
let packet = SftpPacket::Status {
request_id: 1,
code: SSH_FX_OK,
message: "ok".to_string(),
language: "en".to_string(),
};
let mut encoded = packet.encode().unwrap();
encoded.push(0xff);
let payload_length = (encoded.len() - 4) as u32;
encoded[..4].copy_from_slice(&payload_length.to_be_bytes());
let error = SftpPacket::decode(&encoded).unwrap_err();
assert_eq!(error.kind(), std::io::ErrorKind::InvalidData);
}
#[test]
fn malformed_string_length_does_not_reserve_declared_size() {
let bytes = [
0, 0, 0, 9, 103, 0, 0, 0, 1, 0xff, 0xff, 0xff, 0xff, ];
let error = SftpPacket::decode(&bytes).unwrap_err();
assert_eq!(error.kind(), std::io::ErrorKind::UnexpectedEof);
}
#[test]
fn malformed_name_count_is_rejected_before_reserving_entries() {
let bytes = [
0, 0, 0, 9, 104, 0, 0, 0, 1, 0xff, 0xff, 0xff, 0xff, ];
let error = SftpPacket::decode(&bytes).unwrap_err();
assert_eq!(error.kind(), std::io::ErrorKind::UnexpectedEof);
}
#[test]
fn frame_length_addition_rejects_platform_size_overflow() {
let error = super::codec::checked_frame_length(usize::MAX).unwrap_err();
assert_eq!(error.kind(), std::io::ErrorKind::InvalidData);
}
#[test]
fn maximum_sftp_frame_size_is_inclusive_of_the_length_prefix() {
assert_eq!(
super::codec::checked_frame_length(MAX_SFTP_FRAME_SIZE - 4).unwrap(),
MAX_SFTP_FRAME_SIZE
);
}
#[test]
fn decoder_rejects_oversized_frame_from_length_prefix_alone() {
let payload_length = u32::try_from(MAX_SFTP_FRAME_SIZE - 3).unwrap();
let error = SftpPacket::decode(&payload_length.to_be_bytes()).unwrap_err();
assert_eq!(error.kind(), std::io::ErrorKind::InvalidData);
assert!(error.to_string().contains("exceeds the maximum"));
}
#[test]
fn encoder_rejects_frame_larger_than_the_protocol_cap() {
let packet = SftpPacket::Data {
request_id: 1,
data: vec![0; MAX_SFTP_FRAME_SIZE],
};
let error = packet.encode().unwrap_err();
assert_eq!(error.kind(), std::io::ErrorKind::InvalidData);
assert!(error.to_string().contains("exceeds the maximum"));
}
#[cfg(target_pointer_width = "64")]
#[test]
fn wire_lengths_reject_values_larger_than_u32() {
let error = super::wire::checked_u32_length(u32::MAX as usize + 1, "test length").unwrap_err();
assert_eq!(error.kind(), std::io::ErrorKind::InvalidInput);
}
#[test]
fn test_packet_type_codes() {
assert_eq!(SftpPacket::Init { version: 3 }.packet_type(), SSH_FXP_INIT);
assert_eq!(
SftpPacket::Version {
version: 3,
extensions: vec![]
}
.packet_type(),
SSH_FXP_VERSION
);
assert_eq!(
SftpPacket::Open {
request_id: 0,
filename: String::new(),
flags: 0,
attrs: SftpFileAttrs::default(),
}
.packet_type(),
SSH_FXP_OPEN
);
}
#[test]
fn test_request_id_extraction() {
assert!(SftpPacket::Init { version: 3 }.request_id().is_none());
assert!(
SftpPacket::Version {
version: 3,
extensions: vec![]
}
.request_id()
.is_none()
);
assert_eq!(
SftpPacket::Open {
request_id: 42,
filename: String::new(),
flags: 0,
attrs: SftpFileAttrs::default(),
}
.request_id(),
Some(42)
);
assert_eq!(
SftpPacket::Status {
request_id: 99,
code: SSH_FX_OK,
message: String::new(),
language: String::new(),
}
.request_id(),
Some(99)
);
}
#[test]
fn test_file_attrs_directory_check() {
let dir_attrs = SftpFileAttrs::full(4096, 0, 0, 0o040755, 0, 0);
assert!(dir_attrs.is_directory());
assert!(!dir_attrs.is_regular_file());
let file_attrs = SftpFileAttrs::full(100, 0, 0, 0o100644, 0, 0);
assert!(file_attrs.is_regular_file());
assert!(!file_attrs.is_directory());
let link_attrs = SftpFileAttrs::full(10, 0, 0, 0o120777, 0, 0);
assert!(link_attrs.is_symlink());
}
#[test]
fn test_status_code_descriptions() {
assert_eq!(status_code_description(SSH_FX_OK), "Operation succeeded");
assert_eq!(status_code_description(SSH_FX_EOF), "End of file");
assert_eq!(status_code_description(999), "Unknown status code");
}
#[test]
fn test_write_and_read_roundtrip() {
let mut buf = Vec::new();
write_u32(&mut buf, 0xDEADBEEF).unwrap();
write_u64(&mut buf, 0xCAFEBABE_CAFEBABE).unwrap();
write_string(&mut buf, "hello").unwrap();
write_string_raw(&mut buf, &[0x01, 0x02]).unwrap();
let mut cursor = io::Cursor::new(&buf);
assert_eq!(read_u32(&mut cursor).unwrap(), 0xDEADBEEF);
assert_eq!(read_u64(&mut cursor).unwrap(), 0xCAFEBABE_CAFEBABE);
assert_eq!(read_string(&mut cursor).unwrap(), "hello");
assert_eq!(read_raw(&mut cursor).unwrap(), vec![0x01, 0x02]);
}