use super::*;
use std::fs;
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;
use crate::engine::resume_data::ResumeData;
use crate::request::request_group::{
DownloadOptions, FollowMode, GroupId, MetadataInfo, RequestGroup,
};
use crate::util::rwlock_ext::RwLockRecover;
fn create_test_session_dir() -> PathBuf {
let ts = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap_or_default()
.as_nanos()
% 1_000_000_000;
let dir =
std::env::temp_dir().join(format!("aria2_session_test_{}_{}", std::process::id(), ts));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("Failed to create test session directory");
dir
}
fn create_test_groups(count: usize) -> Vec<Arc<std::sync::RwLock<RequestGroup>>> {
let mut groups = Vec::new();
for i in 0..count {
let gid = GroupId::new(i as u64 + 1000);
let uri = format!("http://example.com/file{}.bin", i);
let options = DownloadOptions {
dir: Some("/downloads".to_string()),
split: Some(4),
..Default::default()
};
let group = Arc::new(std::sync::RwLock::new(RequestGroup::new(
gid,
vec![uri],
options,
)));
groups.push(group);
}
groups
}
#[tokio::test]
async fn test_session_save_creates_files() {
let session_dir = create_test_session_dir();
let persistence = SessionPersistence::new(&session_dir);
let groups = create_test_groups(3);
let saved_count = persistence
.save_state(&groups)
.await
.expect("Save should succeed");
assert_eq!(saved_count, 3, "Should save 3 commands");
let entries: Vec<_> = fs::read_dir(&session_dir)
.expect("Should read session dir")
.filter_map(|e| e.ok())
.collect();
let aria2_count = entries
.iter()
.filter(|e| {
e.path()
.extension()
.map(|ext| ext == "aria2")
.unwrap_or(false)
})
.count();
assert_eq!(aria2_count, 3, "Should have 3 .aria2 files");
for entry in entries.iter().filter(|e| {
e.path()
.extension()
.map(|ext| ext == "aria2")
.unwrap_or(false)
}) {
let content = fs::read_to_string(entry.path()).expect("Should read file");
let parsed: serde_json::Value =
serde_json::from_str(&content).expect("Should be valid JSON");
assert!(
parsed.get("gid").is_some(),
"Each .aria2 file should contain a GID field"
);
}
let _ = fs::remove_dir_all(&session_dir);
}
#[tokio::test]
async fn test_session_save_removes_stale_resume_files() {
let session_dir = create_test_session_dir();
let persistence = SessionPersistence::new(&session_dir);
let groups = create_test_groups(1);
let resume_path = session_dir.join(format!(
"{}.aria2",
groups[0].recover().gid().to_hex_string()
));
persistence.save_state(&groups).await.unwrap();
assert!(resume_path.exists());
let empty_groups: Vec<Arc<std::sync::RwLock<RequestGroup>>> = Vec::new();
persistence.save_state(&empty_groups).await.unwrap();
assert!(
!resume_path.exists(),
"an empty authoritative snapshot must remove stale resume files"
);
let _ = fs::remove_dir_all(&session_dir);
}
#[tokio::test]
async fn test_generated_children_are_excluded_from_json_persistence() {
let session_dir = create_test_session_dir();
let persistence = SessionPersistence::new(&session_dir);
let parent = Arc::new(std::sync::RwLock::new(RequestGroup::new(
GroupId::new(2001),
vec!["http://example.com/metadata.torrent".to_string()],
DownloadOptions::default(),
)));
let child = Arc::new(std::sync::RwLock::new(RequestGroup::new(
GroupId::new(2002),
vec!["http://example.com/payload.bin".to_string()],
DownloadOptions::default(),
)));
child.recover().set_belongs_to_gid(GroupId::new(2001));
let saved = persistence.save_state(&[parent, child]).await.unwrap();
assert_eq!(saved, 1);
assert!(session_dir.join("00000000000007d1.aria2").exists());
assert!(!session_dir.join("00000000000007d2.aria2").exists());
let _ = fs::remove_dir_all(&session_dir);
}
#[tokio::test]
async fn test_session_load_restores_commands() {
let session_dir = create_test_session_dir();
let mut persistence = SessionPersistence::new(&session_dir);
let original_groups = create_test_groups(2);
let saved = persistence
.save_state(&original_groups)
.await
.expect("Save should succeed");
assert_eq!(saved, 2, "Should save 2 commands");
let mut loaded_groups: Vec<Arc<std::sync::RwLock<RequestGroup>>> = Vec::new();
let loaded = persistence
.load_state(&mut loaded_groups)
.await
.expect("Load should succeed");
assert_eq!(loaded, 2, "Should restore 2 commands");
let mut found_uris: Vec<String> = Vec::new();
for group_lock in &loaded_groups {
let group = group_lock.recover();
for uri in group.uris() {
found_uris.push(uri.clone());
}
}
assert!(
found_uris.iter().any(|u| u.contains("file0.bin")),
"Should restore first file URI"
);
assert!(
found_uris.iter().any(|u| u.contains("file1.bin")),
"Should restore second file URI"
);
let _ = fs::remove_dir_all(&session_dir);
}
#[tokio::test]
async fn test_session_restore_preserves_progress_pause_and_bt_state() {
let session_dir = create_test_session_dir();
let persistence = SessionPersistence::new(&session_dir);
let group = Arc::new(std::sync::RwLock::new(RequestGroup::new(
GroupId::new(0x456),
vec!["bt://payload".to_string()],
DownloadOptions {
dir: Some(session_dir.to_string_lossy().into_owned()),
out: Some("payload.bin".to_string()),
checksum: Some(("sha-256".to_string(), "deadbeef".to_string())),
..Default::default()
},
)));
group.recover().set_total_length(4096);
group.recover().set_completed_length(1024);
group.recover().set_uploaded_length(512);
group.recover().set_bt_bitfield(Some(vec![0x80, 0x01]));
group.recover().set_bt_metadata(
8,
512,
"00112233445566778899aabbccddeeff00112233".to_string(),
);
group.recover_mut().pause().unwrap();
assert_eq!(
persistence.save_state(&[Arc::clone(&group)]).await.unwrap(),
1
);
let mut restored = Vec::new();
assert_eq!(
SessionPersistence::new(&session_dir)
.load_state(&mut restored)
.await
.unwrap(),
1
);
let restored = restored[0].recover();
assert_eq!(restored.total_length(), 4096);
assert_eq!(restored.completed_length(), 1024);
assert_eq!(restored.upload_length(), 512);
assert_eq!(restored.get_bt_bitfield(), Some(vec![0x80, 0x01]));
assert_eq!(restored.get_bt_num_pieces(), 8);
assert_eq!(restored.get_bt_piece_length(), 512);
assert_eq!(
restored.get_bt_info_hash_hex().as_deref(),
Some("00112233445566778899aabbccddeeff00112233")
);
assert!(restored.status().is_paused());
assert_eq!(
restored
.options()
.checksum
.as_ref()
.map(|(_, value)| value.as_str()),
Some("deadbeef")
);
assert_eq!(
restored.options().dir.as_deref(),
Some(session_dir.to_string_lossy().as_ref())
);
assert_eq!(restored.options().out.as_deref(), Some("payload.bin"));
let _ = fs::remove_dir_all(&session_dir);
}
#[tokio::test]
async fn test_session_save_empty_no_error() {
let session_dir = create_test_session_dir();
let persistence = SessionPersistence::new(&session_dir);
let empty_groups: Vec<Arc<std::sync::RwLock<RequestGroup>>> = Vec::new();
let result = persistence.save_state(&empty_groups).await;
assert!(result.is_ok(), "Saving empty session should not error");
let saved_count = result.unwrap();
assert_eq!(saved_count, 0, "Empty session should report 0 saved");
assert!(
session_dir.exists(),
"Session dir should be created even for empty save"
);
let _ = fs::remove_dir_all(&session_dir);
}
#[tokio::test]
async fn test_session_corrupted_file_skipped_gracefully() {
let session_dir = create_test_session_dir();
fs::create_dir_all(&session_dir).expect("Session directory should exist");
let corrupt_file = session_dir.join("corrupt-gid.aria2");
fs::write(&corrupt_file, "THIS IS NOT VALID JSON {{{{").expect("Should write corrupt file");
let valid_file = session_dir.join("valid-gid.aria2");
let valid_resume_data = ResumeData {
gid: "abc123".to_string(),
uris: vec![crate::engine::resume_data::UriState {
uri: "http://example.com/valid-file.bin".to_string(),
tried: true,
used: false,
last_result: None,
speed_bytes_per_sec: None,
}],
total_length: 1024,
completed_length: 512,
uploaded_length: 0,
bitfield: vec![],
num_pieces: None,
piece_length: None,
status: "paused".to_string(),
error_message: None,
last_download_time: 0,
created_at: 0,
output_path: Some("/downloads/valid-file.bin".to_string()),
checksum: None,
options: std::collections::HashMap::new(),
resume_offset: Some(512),
bt_info_hash: None,
bt_saved_metadata_path: None,
metalink_data: None,
metalink_file_index: None,
};
valid_resume_data
.save_to_file(&valid_file)
.expect("Should write valid file");
let mut persistence = SessionPersistence::new(&session_dir);
let mut loaded_groups: Vec<Arc<std::sync::RwLock<RequestGroup>>> = Vec::new();
let result = persistence.load_state(&mut loaded_groups).await;
assert!(result.is_ok(), "Load should succeed despite corrupt file");
let loaded_count = result.unwrap();
assert_eq!(
loaded_count, 1,
"Should load 1 valid file (corrupt one skipped)"
);
assert_eq!(loaded_groups.len(), 1, "Should have 1 restored group");
let _ = fs::remove_dir_all(&session_dir);
}
#[tokio::test]
async fn test_session_load_rejects_duplicate_gid() {
let session_dir = create_test_session_dir();
let first = ResumeData {
gid: "2a".to_string(),
uris: vec![crate::engine::resume_data::UriState {
uri: "http://example.com/first.bin".to_string(),
..Default::default()
}],
..Default::default()
};
let second = ResumeData {
gid: "2a".to_string(),
uris: vec![crate::engine::resume_data::UriState {
uri: "http://example.com/second.bin".to_string(),
..Default::default()
}],
..Default::default()
};
first
.save_to_file(&session_dir.join("first.aria2"))
.unwrap();
second
.save_to_file(&session_dir.join("second.aria2"))
.unwrap();
let mut persistence = SessionPersistence::new(&session_dir);
let mut groups = Vec::new();
assert_eq!(persistence.load_state(&mut groups).await.unwrap(), 1);
assert_eq!(groups[0].recover().gid(), GroupId::new(0x2a));
let _ = fs::remove_dir_all(&session_dir);
}
#[tokio::test]
async fn test_metadata_provenance_roundtrip_via_json_persistence() {
let session_dir = create_test_session_dir();
let persistence = SessionPersistence::new(&session_dir);
let group = Arc::new(std::sync::RwLock::new(RequestGroup::new(
GroupId::new(0xabc),
vec!["bt://payload".to_string()],
DownloadOptions::default(),
)));
group.recover().set_metadata_info(
MetadataInfo::new(GroupId::new(0xabc), "https://example.test/meta.torrent")
.with_metadata_path(session_dir.join("payload.torrent").to_string_lossy()),
);
assert_eq!(
persistence.save_state(&[Arc::clone(&group)]).await.unwrap(),
1
);
let mut restored = Vec::new();
assert_eq!(
SessionPersistence::new(&session_dir)
.load_state(&mut restored)
.await
.unwrap(),
1
);
let restored_info = restored[0].recover().metadata_info();
assert!(restored_info.is_some());
assert_eq!(
restored_info.as_ref().and_then(|info| info.metadata_path()),
Some(
session_dir
.join("payload.torrent")
.to_string_lossy()
.as_ref()
)
);
let _ = fs::remove_dir_all(&session_dir);
}
#[tokio::test]
async fn test_follow_mode_variants_roundtrip_via_persistence() {
let session_dir = create_test_session_dir();
let persistence = SessionPersistence::new(&session_dir);
let modes = [
(FollowMode::Follow, FollowMode::Disabled),
(FollowMode::Disabled, FollowMode::Follow),
(FollowMode::Memory, FollowMode::Memory),
];
let groups = modes
.iter()
.enumerate()
.map(|(index, &(follow_torrent, follow_metalink))| {
Arc::new(std::sync::RwLock::new(RequestGroup::new(
GroupId::new(0x400 + index as u64),
vec![format!("https://example.test/metadata-{index}.bin")],
DownloadOptions {
follow_torrent: Some(follow_torrent),
follow_metalink: Some(follow_metalink),
..Default::default()
},
)))
})
.collect::<Vec<_>>();
assert_eq!(persistence.save_state(&groups).await.unwrap(), modes.len());
let mut restored = Vec::new();
assert_eq!(
SessionPersistence::new(&session_dir)
.load_state(&mut restored)
.await
.unwrap(),
modes.len()
);
for (index, &(follow_torrent, follow_metalink)) in modes.iter().enumerate() {
let group = restored
.iter()
.find(|group| group.recover().gid() == GroupId::new(0x400 + index as u64))
.expect("follow-mode group should be restored");
let options = group.recover().options().clone();
assert_eq!(options.follow_torrent, Some(follow_torrent));
assert_eq!(options.follow_metalink, Some(follow_metalink));
}
let _ = fs::remove_dir_all(&session_dir);
}
#[cfg(all(feature = "metalink", feature = "bittorrent"))]
#[tokio::test]
async fn test_metalink_torrent_graph_is_rebuilt_after_session_load() {
let session_dir = create_test_session_dir();
let persistence = SessionPersistence::new(&session_dir);
let metadata_path = session_dir.join("payload.torrent");
let payload = Arc::new(std::sync::RwLock::new(RequestGroup::new(
GroupId::new(0x222),
vec!["bt://metadata".to_string()],
DownloadOptions {
dir: Some(session_dir.to_string_lossy().into_owned()),
out: Some("payload.bin".to_string()),
..Default::default()
},
)));
payload.recover().set_metadata_info(
MetadataInfo::new(GroupId::new(0x111), "https://example.test/payload.torrent")
.with_metadata_path(metadata_path.to_string_lossy()),
);
assert_eq!(
persistence
.save_state(&[Arc::clone(&payload)])
.await
.unwrap(),
1
);
let mut restored = Vec::new();
assert_eq!(
SessionPersistence::new(&session_dir)
.load_state(&mut restored)
.await
.unwrap(),
1
);
assert_eq!(restored.len(), 2);
let metadata = restored
.iter()
.find(|group| group.recover().gid() == GroupId::new(0x111))
.expect("metadata prerequisite should be restored");
assert_eq!(
metadata.recover().uris(),
&["https://example.test/payload.torrent".to_string()]
);
assert_eq!(
metadata.recover().belongs_to_gid(),
Some(GroupId::new(0x222))
);
let restored_payload = restored
.iter()
.find(|group| group.recover().gid() == GroupId::new(0x222))
.expect("payload should be restored");
assert!(!restored_payload.recover().is_dependency_resolved());
assert_eq!(
restored_payload.recover().metadata_info().unwrap().gid(),
Some(GroupId::new(0x111))
);
let _ = fs::remove_dir_all(&session_dir);
}
#[cfg(all(feature = "metalink", feature = "bittorrent"))]
#[tokio::test]
async fn test_json_session_roundtrip_preserves_metalink_graph_descriptor() {
let session_dir = create_test_session_dir();
let options = DownloadOptions {
dir: Some(session_dir.to_string_lossy().into_owned()),
..Default::default()
};
let graph = crate::engine::metalink_request_graph::MetalinkRequestGraph::new_memory_with_fallback_and_mappings(
"https://example.test/payload.torrent",
"payload.bin",
&options,
GroupId::new(0x501),
GroupId::new(0x502),
vec!["https://mirror.example.test/payload.bin".to_string()],
vec![crate::request::request_group::BtFileMapping {
original_name: "payload.bin".to_string(),
path: session_dir.join("payload.bin").to_string_lossy().into_owned(),
uris: vec!["https://mirror.example.test/payload.bin".to_string()],
max_connection_per_server: 3,
unique_protocol: true,
}],
)
.unwrap();
let torrent_data = {
let mut data =
b"d8:announce28:http://tracker.test/announce4:infod6:lengthi0e4:name4:test12:piece lengthi16384e6:pieces20:".to_vec();
data.extend_from_slice(&[
0xda, 0x39, 0xa3, 0xee, 0x5e, 0x6b, 0x4b, 0x0d, 0x32, 0x55, 0xbf, 0xef, 0x95, 0x60,
0x18, 0x90, 0xaf, 0xd8, 0x07, 0x09,
]);
data.extend_from_slice(b"ee");
data
};
let torrent_len = torrent_data.len();
graph
.payload
.recover()
.set_bt_metadata_data(torrent_data.clone());
let persistence = SessionPersistence::new(&session_dir);
assert_eq!(
persistence
.save_state(&[Arc::clone(&graph.payload)])
.await
.unwrap(),
1
);
let mut restored = Vec::new();
assert_eq!(
SessionPersistence::new(&session_dir)
.load_state(&mut restored)
.await
.unwrap(),
1
);
assert_eq!(restored.len(), 2);
let payload = restored
.iter()
.find(|group| group.recover().gid() == GroupId::new(0x502))
.expect("payload should be restored");
let descriptor = payload
.recover()
.bt_dependency_descriptor()
.expect("BT dependency descriptor should be rebuilt");
assert!(descriptor.0);
assert_eq!(
descriptor.1,
vec!["https://mirror.example.test/payload.bin"]
);
assert_eq!(descriptor.2.len(), 1);
assert_eq!(descriptor.2[0].max_connection_per_server, 3);
assert!(descriptor.2[0].unique_protocol);
assert_eq!(payload.recover().bt_metadata_data(), Some(torrent_data));
let metadata = restored
.iter()
.find(|group| group.recover().gid() == GroupId::new(0x501))
.expect("metadata source should be restored");
assert!(metadata.recover().is_in_memory_download());
assert_eq!(
metadata.recover().in_memory_data().map(|data| data.len()),
Some(torrent_len)
);
let _ = fs::remove_dir_all(&session_dir);
}
#[tokio::test]
async fn test_session_load_nonexistent_dir_returns_zero() {
let nonexistent_dir =
PathBuf::from("/tmp/aria2_nonexistent_test_dir_that_should_not_exist_12345");
let mut persistence = SessionPersistence::new(&nonexistent_dir);
let mut groups: Vec<Arc<std::sync::RwLock<RequestGroup>>> = Vec::new();
let result = persistence.load_state(&mut groups).await;
assert!(result.is_ok(), "Nonexistent dir should return Ok");
assert_eq!(result.unwrap(), 0, "Nonexistent dir should return 0 loaded");
assert!(groups.is_empty(), "No groups should be added");
}
#[tokio::test]
async fn test_session_cleanup_removes_all_files() {
let session_dir = create_test_session_dir();
let persistence = SessionPersistence::new(&session_dir);
let groups = create_test_groups(2);
let _ = persistence.save_state(&groups).await.unwrap();
assert!(
session_dir.exists(),
"Session dir should exist before cleanup"
);
persistence.cleanup().await.expect("Cleanup should succeed");
if session_dir.exists() {
let remaining: Vec<_> = fs::read_dir(&session_dir)
.expect("Should read dir")
.filter_map(|e| e.ok())
.collect();
assert!(
remaining.is_empty(),
"All files should be removed after cleanup"
);
}
let _ = fs::remove_dir_all(&session_dir);
}
#[tokio::test]
async fn test_session_custom_interval() {
let session_dir = create_test_session_dir();
let persistence = SessionPersistence::new(&session_dir).with_interval(30);
assert_eq!(
persistence.auto_save_interval,
Duration::from_secs(30),
"Custom interval should be set"
);
let short_interval = SessionPersistence::new(&session_dir).with_interval(1);
assert!(
short_interval.auto_save_interval >= Duration::from_secs(10),
"Interval should be at least 10 seconds"
);
let _ = fs::remove_dir_all(&session_dir);
}
#[tokio::test]
async fn test_resume_data_roundtrip_via_persistence() {
let session_dir = create_test_session_dir();
let mut persistence = SessionPersistence::new(&session_dir);
let gid = GroupId::new(0xDEADBEEF);
let options = DownloadOptions {
dir: Some("/test/downloads".to_string()),
out: Some("special_file.iso".to_string()),
split: Some(16),
..Default::default()
};
let group = Arc::new(std::sync::RwLock::new(RequestGroup::new(
gid,
vec!["http://example.com/special_file.iso".to_string()],
options,
)));
{
let g = group.recover_mut();
g.set_total_length_atomic(10485760); g.set_completed_length(5242880); }
let saved = persistence.save_state(&[group]).await.unwrap();
assert_eq!(saved, 1);
let mut loaded: Vec<Arc<std::sync::RwLock<RequestGroup>>> = Vec::new();
let loaded_count = persistence.load_state(&mut loaded).await.unwrap();
assert_eq!(loaded_count, 1);
let restored = loaded[0].read().unwrap();
let uris = restored.uris();
assert_eq!(uris.len(), 1);
assert!(uris[0].contains("special_file.iso"));
let _ = fs::remove_dir_all(&session_dir);
}
#[tokio::test]
async fn test_selective_save_active_only() {
let session_dir = create_test_session_dir();
let persistence = SessionPersistence::new(&session_dir);
let mut groups: Vec<Arc<std::sync::RwLock<RequestGroup>>> = Vec::new();
let active_gid = GroupId::new(1001);
let active_group = Arc::new(std::sync::RwLock::new(RequestGroup::new(
active_gid,
vec!["http://example.com/active.bin".to_string()],
DownloadOptions::default(),
)));
{
let mut g = active_group.recover_mut();
g.start().unwrap(); }
groups.push(active_group);
let waiting_gid = GroupId::new(1002);
let waiting_group = Arc::new(std::sync::RwLock::new(RequestGroup::new(
waiting_gid,
vec!["http://example.com/waiting.bin".to_string()],
DownloadOptions::default(),
)));
groups.push(waiting_group);
let complete_gid = GroupId::new(1003);
let complete_group = Arc::new(std::sync::RwLock::new(RequestGroup::new(
complete_gid,
vec!["http://example.com/complete.bin".to_string()],
DownloadOptions::default(),
)));
{
let mut g = complete_group.recover_mut();
g.complete().unwrap(); }
groups.push(complete_group);
let saved_count = persistence.save_active_only(&groups).await.unwrap();
assert_eq!(
saved_count, 2,
"save_active_only should save only active and waiting downloads"
);
let entries: Vec<_> = fs::read_dir(&session_dir)
.expect("Should read session dir")
.filter_map(|e| e.ok())
.filter(|e| {
e.path()
.extension()
.map(|ext| ext == "aria2")
.unwrap_or(false)
})
.collect();
assert_eq!(
entries.len(),
2,
"Should have exactly 2 .aria2 files for active+waiting"
);
let _ = fs::remove_dir_all(&session_dir);
}
#[test]
fn test_dht_snapshot_roundtrip() {
use crate::session::session_persistence::{DhtNodeInfo, DhtStateSnapshot};
let node1 = DhtNodeInfo {
id: [1u8; 20],
addr: "192.168.1.100:6881".to_string(),
last_seen_epoch_secs: 1700000000,
};
let node2 = DhtNodeInfo {
id: [2u8; 20],
addr: "10.0.0.5:6881".to_string(),
last_seen_epoch_secs: 1700000100,
};
let token_secret: [u8; 20] = [0xAB; 20];
let original = DhtStateSnapshot::new(vec![node1, node2], token_secret, Some(1699999000));
assert_eq!(original.total_nodes, 2);
assert_eq!(original.nodes.len(), 2);
assert!(original.last_bootstrap_epoch_secs.is_some());
let json = original
.to_json_string()
.expect("Serialization should succeed");
assert!(!json.is_empty(), "JSON output should not be empty");
assert!(
json.contains("192.168.1.100"),
"JSON should contain first node address"
);
assert!(
json.contains("10.0.0.5"),
"JSON should contain second node address"
);
let restored =
DhtStateSnapshot::from_json_string(&json).expect("Deserialization should succeed");
assert_eq!(restored.total_nodes, 2, "total_nodes should be preserved");
assert_eq!(restored.nodes.len(), 2, "nodes count should be preserved");
assert_eq!(
restored.token_secret, token_secret,
"token_secret should be preserved"
);
assert_eq!(
restored.last_bootstrap_epoch_secs,
Some(1699999000),
"last_bootstrap_epoch_secs should be preserved"
);
assert_eq!(
restored.nodes[0].id, [1u8; 20],
"First node ID should match"
);
assert_eq!(
restored.nodes[0].addr, "192.168.1.100:6881",
"First node address should match"
);
assert_eq!(
restored.nodes[0].last_seen_epoch_secs, 1700000000,
"First node timestamp should match"
);
assert_eq!(
restored.nodes[1].id, [2u8; 20],
"Second node ID should match"
);
assert_eq!(
restored.nodes[1].addr, "10.0.0.5:6881",
"Second node address should match"
);
let empty = DhtStateSnapshot::empty();
assert_eq!(empty.total_nodes, 0, "Empty snapshot should have 0 nodes");
assert!(
empty.nodes.is_empty(),
"Empty snapshot should have no nodes"
);
let empty_json = empty
.to_json_string()
.expect("Empty serialization should succeed");
let empty_restored =
DhtStateSnapshot::from_json_string(&empty_json).expect("Empty deserialization should work");
assert_eq!(
empty_restored.total_nodes, 0,
"Restored empty should still be empty"
);
}
#[tokio::test]
async fn test_cookie_persist_integration() {
use crate::http::cookie_storage::{CookieJar, JarCookie};
let session_dir = create_test_session_dir();
let mut jar = CookieJar::new();
jar.store(JarCookie::new("session_id", "abc123", "example.com"));
jar.store(JarCookie::new("auth_token", "xyz789", "api.example.com"));
let persistence_with_cookies = SessionPersistence::new(&session_dir).with_cookie_jar(jar);
assert!(
persistence_with_cookies.cookie_jar().is_some(),
"Cookie jar should be set"
);
assert_eq!(
persistence_with_cookies.cookie_jar().unwrap().len(),
2,
"Should have 2 cookies before save"
);
let groups: Vec<Arc<std::sync::RwLock<RequestGroup>>> = Vec::new();
let _saved = persistence_with_cookies.save_state(&groups).await.unwrap();
let cookie_path = session_dir.join("cookies.json");
assert!(
cookie_path.exists(),
"cookies.json file should exist after save"
);
let mut persistence_new = SessionPersistence::new(&session_dir);
let mut loaded_groups: Vec<Arc<std::sync::RwLock<RequestGroup>>> = Vec::new();
let _loaded = persistence_new
.load_state(&mut loaded_groups)
.await
.unwrap();
assert!(
persistence_new.cookie_jar().is_some(),
"Cookie jar should exist after load"
);
let loaded_jar = persistence_new.cookie_jar().unwrap();
assert_eq!(
loaded_jar.len(),
2,
"Should have loaded 2 cookies from file"
);
let example_cookies = loaded_jar.get_cookies_for_url("http://example.com/", false);
assert_eq!(
example_cookies.len(),
1,
"Should find 1 cookie for example.com"
);
assert_eq!(example_cookies[0].name, "session_id");
assert_eq!(example_cookies[0].value, "abc123");
let api_cookies = loaded_jar.get_cookies_for_url("http://api.example.com/api", false);
assert_eq!(
api_cookies.len(),
2,
"Should find 2 cookies for api.example.com (parent domain + exact)"
);
let auth_cookie = api_cookies
.iter()
.find(|c| c.name == "auth_token")
.expect("Should find auth_token cookie");
assert_eq!(auth_cookie.value, "xyz789");
let session_cookie = api_cookies
.iter()
.find(|c| c.name == "session_id")
.expect("Should find session_id cookie from parent domain");
assert_eq!(session_cookie.value, "abc123");
let _ = fs::remove_dir_all(&session_dir);
}
#[tokio::test]
async fn test_auto_save_with_custom_interval() {
let session_dir = create_test_session_dir();
let persistence_30s = SessionPersistence::new(&session_dir).with_interval(30);
assert_eq!(
persistence_30s.auto_save_interval,
Duration::from_secs(30),
"Custom 30s interval should be set"
);
let persistence_too_short = SessionPersistence::new(&session_dir).with_interval(1);
assert!(
persistence_too_short.auto_save_interval >= Duration::from_secs(10),
"Interval below minimum should be clamped to 10s"
);
let persistence_exact_min = SessionPersistence::new(&session_dir).with_interval(10);
assert_eq!(
persistence_exact_min.auto_save_interval,
Duration::from_secs(10),
"Exact minimum interval (10s) should be accepted"
);
let persistence_large = SessionPersistence::new(&session_dir).with_interval(300); assert_eq!(
persistence_large.auto_save_interval,
Duration::from_secs(300),
"Large interval (300s) should be accepted"
);
let persistence_default = SessionPersistence::new(&session_dir);
assert!(
persistence_default.auto_save_enabled,
"Auto-save should be enabled by default"
);
assert_eq!(
persistence_default.auto_save_interval,
Duration::from_secs(DEFAULT_AUTO_SAVE_INTERVAL_SECS),
"Default interval should be 60 seconds"
);
let persistence_disabled = SessionPersistence::new(&session_dir).without_auto_save();
assert!(
!persistence_disabled.auto_save_enabled,
"Auto-save should be disabled after without_auto_save()"
);
let _ = fs::remove_dir_all(&session_dir);
}