pinakes-core: expand test coverage for new file/media management ops

Signed-off-by: NotAShelf <raf@notashelf.dev>
Change-Id: I2c7ac0c2717839cc014436d1d2e895796a6a6964

crates/pinakes-core/tests/integrity.rs

@@ -0,0 +1,178 @@
+use std::fs;
+
+use pinakes_core::integrity::detect_orphans;
+
+mod common;
+use common::{create_test_media_item, setup_test_storage};
+
+#[tokio::test]
+async fn test_detect_orphaned_files() {
+    let (storage, temp_dir) = setup_test_storage().await;
+
+    let nonexistent_path = temp_dir.path().join("nonexistent.mp3");
+    let orphaned_item = create_test_media_item(nonexistent_path, "hash1");
+
+    storage.insert_media(&orphaned_item).await.unwrap();
+
+    let report = detect_orphans(&storage).await.unwrap();
+
+    assert_eq!(report.orphaned_ids.len(), 1);
+    assert_eq!(report.orphaned_ids[0], orphaned_item.id);
+}
+
+#[tokio::test]
+async fn test_detect_untracked_files() {
+    let (storage, temp_dir) = setup_test_storage().await;
+
+    let root_dir = temp_dir.path().join("media");
+    fs::create_dir(&root_dir).unwrap();
+    storage.add_root_dir(root_dir.clone()).await.unwrap();
+
+    let tracked_file = root_dir.join("tracked.mp3");
+    let untracked_file = root_dir.join("untracked.mp3");
+
+    fs::write(&tracked_file, b"tracked content").unwrap();
+    fs::write(&untracked_file, b"untracked content").unwrap();
+
+    let tracked_item = create_test_media_item(tracked_file.clone(), "hash_tracked");
+    storage.insert_media(&tracked_item).await.unwrap();
+
+    let report = detect_orphans(&storage).await.unwrap();
+
+    assert_eq!(report.untracked_paths.len(), 1);
+    assert!(report.untracked_paths.contains(&untracked_file));
+}
+
+#[tokio::test]
+async fn test_detect_moved_files() {
+    let (storage, temp_dir) = setup_test_storage().await;
+
+    let old_path = temp_dir.path().join("old_location.mp3");
+
+    fs::write(&old_path, b"content").unwrap();
+
+    let old_item = create_test_media_item(old_path.clone(), "hash_unique");
+    storage.insert_media(&old_item).await.unwrap();
+
+    fs::remove_file(&old_path).unwrap();
+
+    let report = detect_orphans(&storage).await.unwrap();
+
+    assert_eq!(report.orphaned_ids.len(), 1);
+    assert_eq!(report.moved_files.len(), 0);
+}
+
+#[tokio::test]
+async fn test_ignore_patterns_respected() {
+    let (storage, temp_dir) = setup_test_storage().await;
+
+    let root_dir = temp_dir.path().join("media");
+    fs::create_dir(&root_dir).unwrap();
+    storage.add_root_dir(root_dir.clone()).await.unwrap();
+
+    let hidden_dir = root_dir.join(".hidden");
+    fs::create_dir(&hidden_dir).unwrap();
+
+    let hidden_file = hidden_dir.join("hidden.mp3");
+    fs::write(&hidden_file, b"hidden content").unwrap();
+
+    let normal_file = root_dir.join("normal.mp3");
+    fs::write(&normal_file, b"normal content").unwrap();
+
+    let report = detect_orphans(&storage).await.unwrap();
+
+    assert_eq!(report.untracked_paths.len(), 1);
+    assert!(report.untracked_paths.contains(&normal_file));
+    assert!(!report.untracked_paths.contains(&hidden_file));
+}
+
+#[tokio::test]
+async fn test_only_supported_media_types() {
+    let (storage, temp_dir) = setup_test_storage().await;
+
+    let root_dir = temp_dir.path().join("media");
+    fs::create_dir(&root_dir).unwrap();
+    storage.add_root_dir(root_dir.clone()).await.unwrap();
+
+    let mp3_file = root_dir.join("audio.mp3");
+    let txt_file = root_dir.join("readme.txt");
+    let exe_file = root_dir.join("program.exe");
+
+    fs::write(&mp3_file, b"audio").unwrap();
+    fs::write(&txt_file, b"text").unwrap();
+    fs::write(&exe_file, b"binary").unwrap();
+
+    let report = detect_orphans(&storage).await.unwrap();
+
+    assert!(report.untracked_paths.len() <= 2);
+    assert!(!report.untracked_paths.contains(&exe_file));
+}
+
+#[tokio::test]
+async fn test_complete_orphan_workflow() {
+    let (storage, temp_dir) = setup_test_storage().await;
+
+    let root_dir = temp_dir.path().join("media");
+    fs::create_dir(&root_dir).unwrap();
+    storage.add_root_dir(root_dir.clone()).await.unwrap();
+
+    let orphaned_path = root_dir.join("orphaned.mp3");
+    let orphaned_item = create_test_media_item(orphaned_path.clone(), "hash_orphaned");
+    storage.insert_media(&orphaned_item).await.unwrap();
+
+    let untracked_path = root_dir.join("untracked.mp3");
+    fs::write(&untracked_path, b"untracked").unwrap();
+
+    let another_orphaned = root_dir.join("another_orphaned.mp3");
+    let another_item = create_test_media_item(another_orphaned.clone(), "hash_another");
+    storage.insert_media(&another_item).await.unwrap();
+
+    let tracked_path = root_dir.join("tracked.mp3");
+    fs::write(&tracked_path, b"tracked").unwrap();
+
+    let tracked_item = create_test_media_item(tracked_path.clone(), "hash_tracked");
+    storage.insert_media(&tracked_item).await.unwrap();
+
+    let report = detect_orphans(&storage).await.unwrap();
+
+    assert_eq!(report.orphaned_ids.len(), 2);
+    assert!(report.orphaned_ids.contains(&orphaned_item.id));
+    assert!(report.orphaned_ids.contains(&another_item.id));
+
+    assert_eq!(report.untracked_paths.len(), 1);
+    assert!(report.untracked_paths.contains(&untracked_path));
+
+    assert_eq!(report.moved_files.len(), 0);
+}
+
+#[tokio::test]
+async fn test_large_directory_performance() {
+    let (storage, temp_dir) = setup_test_storage().await;
+
+    let root_dir = temp_dir.path().join("media");
+    fs::create_dir(&root_dir).unwrap();
+    storage.add_root_dir(root_dir.clone()).await.unwrap();
+
+    for i in 0..1000 {
+        let file_path = root_dir.join(format!("file_{}.mp3", i));
+        fs::write(&file_path, format!("content {}", i)).unwrap();
+    }
+
+    for i in 0..500 {
+        let file_path = root_dir.join(format!("file_{}.mp3", i));
+        let item = create_test_media_item(file_path, &format!("hash_{}", i));
+        storage.insert_media(&item).await.unwrap();
+    }
+
+    let start = std::time::Instant::now();
+    let report = detect_orphans(&storage).await.unwrap();
+    let elapsed = start.elapsed();
+
+    assert!(
+        elapsed.as_secs() < 5,
+        "Detection took too long: {:?}",
+        elapsed
+    );
+
+    assert_eq!(report.untracked_paths.len(), 500);
+}