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/book_metadata.rs

@@ -0,0 +1,203 @@
+use pinakes_core::books::{extract_isbn_from_text, normalize_isbn, parse_author_file_as};
+use pinakes_core::enrichment::books::BookEnricher;
+use pinakes_core::enrichment::googlebooks::GoogleBooksClient;
+use pinakes_core::enrichment::openlibrary::OpenLibraryClient;
+use pinakes_core::thumbnail::{CoverSize, extract_epub_cover, generate_book_covers};
+
+#[test]
+fn test_isbn_normalization() {
+    // Valid ISBN-10 to ISBN-13 conversion (The Hobbit)
+    let result = normalize_isbn("0547928220");
+    assert!(result.is_ok());
+    let isbn13 = result.unwrap();
+    assert_eq!(isbn13.len(), 13);
+    assert!(isbn13.starts_with("978"));
+
+    // Valid ISBN-13 should return itself
+    let result = normalize_isbn("9780547928227");
+    assert!(result.is_ok());
+    assert_eq!(result.unwrap(), "9780547928227");
+
+    // ISBN with hyphens should be normalized
+    let result = normalize_isbn("978-0-547-92822-7");
+    assert!(result.is_ok());
+    assert_eq!(result.unwrap(), "9780547928227");
+
+    // Invalid ISBN
+    let result = normalize_isbn("invalid");
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_isbn_extraction_from_text() {
+    let text = "This book has ISBN-13: 978-0-123-45678-9 in the middle.";
+    let result = extract_isbn_from_text(text);
+    assert!(result.is_some());
+    let isbn = result.unwrap();
+    assert!(isbn.contains("978"));
+
+    let text_isbn10 = "Old format ISBN: 0-123-45678-9";
+    let result = extract_isbn_from_text(text_isbn10);
+    assert!(result.is_some());
+
+    let text_no_isbn = "This text has no ISBN at all.";
+    let result = extract_isbn_from_text(text_no_isbn);
+    assert!(result.is_none());
+}
+
+#[test]
+fn test_author_file_as_parsing() {
+    // Standard name: "First Last" -> "Last, First"
+    let result = parse_author_file_as("John Smith");
+    assert_eq!(result, "Smith, John");
+
+    // Single name
+    let result = parse_author_file_as("Shakespeare");
+    assert_eq!(result, "Shakespeare");
+
+    // Multiple middle names
+    let result = parse_author_file_as("John Ronald Reuel Tolkien");
+    assert_eq!(result, "Tolkien, John Ronald Reuel");
+
+    // Already in "Last, First" format
+    let result = parse_author_file_as("Tolkien, J.R.R.");
+    assert_eq!(result, "Tolkien, J.R.R.");
+}
+
+#[test]
+fn test_book_enricher_creation() {
+    let enricher = BookEnricher::new(None);
+    // Just verify it can be created
+    drop(enricher);
+
+    let enricher_with_key = BookEnricher::new(Some("test-api-key".to_string()));
+    drop(enricher_with_key);
+}
+
+#[test]
+fn test_openlibrary_client_creation() {
+    let client = OpenLibraryClient::new();
+    // Verify client is created successfully
+    drop(client);
+}
+
+#[test]
+fn test_googlebooks_client_creation() {
+    let client = GoogleBooksClient::new(None);
+    drop(client);
+
+    let client_with_key = GoogleBooksClient::new(Some("test-key".to_string()));
+    drop(client_with_key);
+}
+
+#[test]
+fn test_cover_size_dimensions() {
+    assert_eq!(CoverSize::Tiny.dimensions(), Some((64, 64)));
+    assert_eq!(CoverSize::Grid.dimensions(), Some((320, 320)));
+    assert_eq!(CoverSize::Preview.dimensions(), Some((1024, 1024)));
+    assert_eq!(CoverSize::Original.dimensions(), None);
+}
+
+#[test]
+fn test_cover_size_filenames() {
+    assert_eq!(CoverSize::Tiny.filename(), "tiny.jpg");
+    assert_eq!(CoverSize::Grid.filename(), "grid.jpg");
+    assert_eq!(CoverSize::Preview.filename(), "preview.jpg");
+    assert_eq!(CoverSize::Original.filename(), "original.jpg");
+}
+
+// Note: The following tests would require actual EPUB files and network access,
+// so they're marked as ignored by default. Run with --ignored to execute them.
+
+#[test]
+#[ignore]
+fn test_epub_cover_extraction() {
+    // This test requires a real EPUB file
+    // Create a test EPUB file path
+    let epub_path = std::path::PathBuf::from("test_fixtures/sample.epub");
+
+    if !epub_path.exists() {
+        // Skip if test fixture doesn't exist
+        return;
+    }
+
+    let result = extract_epub_cover(&epub_path);
+    // Should either succeed with Some(data) or None if no cover found
+    assert!(result.is_ok());
+}
+
+#[test]
+#[ignore]
+fn test_book_cover_generation() {
+    // This test requires a sample image
+    use tempfile::tempdir;
+
+    // Create a minimal 100x100 red PNG in memory
+    let mut img_data = Vec::new();
+    {
+        use image::{ImageBuffer, Rgb};
+        let img: ImageBuffer<Rgb<u8>, Vec<u8>> =
+            ImageBuffer::from_fn(100, 100, |_, _| Rgb([255u8, 0u8, 0u8]));
+        img.write_to(
+            &mut std::io::Cursor::new(&mut img_data),
+            image::ImageFormat::Png,
+        )
+        .unwrap();
+    }
+
+    let temp_dir = tempdir().unwrap();
+    let media_id = pinakes_core::model::MediaId::new();
+
+    let result = generate_book_covers(media_id, &img_data, temp_dir.path());
+    assert!(result.is_ok());
+
+    let covers = result.unwrap();
+    assert_eq!(covers.len(), 4); // tiny, grid, preview, original
+
+    // Verify all cover files exist
+    for (size, path) in &covers {
+        assert!(path.exists(), "Cover {:?} should exist at {:?}", size, path);
+    }
+}
+
+#[tokio::test]
+#[ignore]
+async fn test_openlibrary_isbn_fetch() {
+    // This test requires network access
+    let client = OpenLibraryClient::new();
+
+    // Use a known ISBN for "The Hobbit"
+    let result = client.fetch_by_isbn("9780547928227").await;
+
+    // Should either succeed or fail gracefully
+    // We don't assert success because network might not be available
+    match result {
+        Ok(book) => {
+            assert!(book.title.is_some());
+        }
+        Err(_) => {
+            // Network error or book not found - acceptable in tests
+        }
+    }
+}
+
+#[tokio::test]
+#[ignore]
+async fn test_googlebooks_isbn_fetch() {
+    // This test requires network access
+    let client = GoogleBooksClient::new(None);
+
+    // Use a known ISBN
+    let result = client.fetch_by_isbn("9780547928227").await;
+
+    match result {
+        Ok(books) => {
+            if !books.is_empty() {
+                assert!(books[0].volume_info.title.is_some());
+            }
+        }
+        Err(_) => {
+            // Network error - acceptable in tests
+        }
+    }
+}