From fc43589d3a5206a9b555dc868a1db0c92af53802 Mon Sep 17 00:00:00 2001 From: jacksonfu14 Date: Mon, 17 Nov 2025 08:41:32 +0100 Subject: feature: ly processing progress callbacks --- morphology-img/tests/integration.rs | 175 +++++++++++++++++++++++++++++++++++- morphology-img/tests/render.rs | 7 ++ 2 files changed, 181 insertions(+), 1 deletion(-) (limited to 'morphology-img/tests') diff --git a/morphology-img/tests/integration.rs b/morphology-img/tests/integration.rs index e6db544..227e5d1 100644 --- a/morphology-img/tests/integration.rs +++ b/morphology-img/tests/integration.rs @@ -1,7 +1,8 @@ -use morphology_img::{render_sequences, RenderConfig}; +use morphology_img::{render_sequences, RenderConfig, ProgressCallback}; use morphology::{Sequence, Value}; use tempfile::TempDir; use std::fs; +use std::sync::{Arc, Mutex}; /// Test the complete pipeline with basic configuration #[test] @@ -363,3 +364,175 @@ fn test_render_sequences_realistic_workflow() { assert_eq!(svg_paths[0].file_name().unwrap().to_str().unwrap(), "sequence-0.svg"); assert_eq!(svg_paths[3].file_name().unwrap().to_str().unwrap(), "sequence-3.svg"); } + +// Tests for progress callback + +/// Test that progress callback is called correctly +#[test] +#[ignore] +fn test_progress_callback_basic() { + let sequences = vec![ + Sequence::new(vec![Value::origin()]), + Sequence::new(vec![Value::new(1, 0)]), + Sequence::new(vec![Value::new(2, 0)]), + ]; + + let progress_calls = Arc::new(Mutex::new(Vec::new())); + let progress_calls_clone = progress_calls.clone(); + + let callback: ProgressCallback = Arc::new(move |current, total| { + progress_calls_clone.lock().unwrap().push((current, total)); + }); + + let output_dir = TempDir::new().unwrap(); + let config = RenderConfig::new(output_dir.path()) + .progress_callback(callback); + + let svg_paths = render_sequences(&sequences, &config).unwrap(); + + // Verify all SVGs were created + assert_eq!(svg_paths.len(), 3); + + // Verify progress callback was called correctly + let calls = progress_calls.lock().unwrap(); + assert_eq!(calls.len(), 3, "callback should be called once per sequence"); + + // Verify calls have correct values + assert_eq!(calls[0], (1, 3), "first call should be (1, 3)"); + assert_eq!(calls[1], (2, 3), "second call should be (2, 3)"); + assert_eq!(calls[2], (3, 3), "third call should be (3, 3)"); +} + +/// Test progress callback with single sequence +#[test] +#[ignore] +fn test_progress_callback_single() { + let sequences = vec![Sequence::new(vec![Value::origin()])]; + + let progress_calls = Arc::new(Mutex::new(Vec::new())); + let progress_calls_clone = progress_calls.clone(); + + let callback: ProgressCallback = Arc::new(move |current, total| { + progress_calls_clone.lock().unwrap().push((current, total)); + }); + + let output_dir = TempDir::new().unwrap(); + let config = RenderConfig::new(output_dir.path()) + .progress_callback(callback); + + let _svg_paths = render_sequences(&sequences, &config).unwrap(); + + let calls = progress_calls.lock().unwrap(); + assert_eq!(calls.len(), 1); + assert_eq!(calls[0], (1, 1)); +} + +/// Test progress callback with many sequences +#[test] +#[ignore] +fn test_progress_callback_many() { + let sequences: Vec = (0..10) + .map(|i| Sequence::new(vec![Value::new(i, 0)])) + .collect(); + + let progress_calls = Arc::new(Mutex::new(Vec::new())); + let progress_calls_clone = progress_calls.clone(); + + let callback: ProgressCallback = Arc::new(move |current, total| { + progress_calls_clone.lock().unwrap().push((current, total)); + }); + + let output_dir = TempDir::new().unwrap(); + let config = RenderConfig::new(output_dir.path()) + .progress_callback(callback); + + let svg_paths = render_sequences(&sequences, &config).unwrap(); + + assert_eq!(svg_paths.len(), 10); + + let calls = progress_calls.lock().unwrap(); + assert_eq!(calls.len(), 10); + + // Verify each call has correct values + for (i, &(current, total)) in calls.iter().enumerate() { + assert_eq!(current, i + 1); + assert_eq!(total, 10); + } +} + +/// Test that rendering works without progress callback +#[test] +#[ignore] +fn test_no_progress_callback() { + let sequences = vec![ + Sequence::new(vec![Value::origin()]), + Sequence::new(vec![Value::new(1, 0)]), + ]; + + let output_dir = TempDir::new().unwrap(); + let config = RenderConfig::new(output_dir.path()); + // No progress callback set + + let svg_paths = render_sequences(&sequences, &config).unwrap(); + + // Should work normally without callback + assert_eq!(svg_paths.len(), 2); + for svg_path in &svg_paths { + assert!(svg_path.exists()); + } +} + +/// Test progress callback with empty sequence list +#[test] +#[ignore] +fn test_progress_callback_empty() { + let sequences: Vec = vec![]; + + let progress_calls = Arc::new(Mutex::new(Vec::new())); + let progress_calls_clone = progress_calls.clone(); + + let callback: ProgressCallback = Arc::new(move |current, total| { + progress_calls_clone.lock().unwrap().push((current, total)); + }); + + let output_dir = TempDir::new().unwrap(); + let config = RenderConfig::new(output_dir.path()) + .progress_callback(callback); + + let svg_paths = render_sequences(&sequences, &config).unwrap(); + + assert_eq!(svg_paths.len(), 0); + + // Callback should not be called for empty list + let calls = progress_calls.lock().unwrap(); + assert_eq!(calls.len(), 0, "callback should not be called for empty input"); +} + +/// Test that progress callback can track actual progress +#[test] +#[ignore] +fn test_progress_callback_tracking() { + let sequences: Vec = (0..5) + .map(|i| Sequence::new(vec![Value::new(i, 0)])) + .collect(); + + let last_progress = Arc::new(Mutex::new((0, 0))); + let last_progress_clone = last_progress.clone(); + + let callback: ProgressCallback = Arc::new(move |current, total| { + let mut progress = last_progress_clone.lock().unwrap(); + *progress = (current, total); + }); + + let output_dir = TempDir::new().unwrap(); + let config = RenderConfig::new(output_dir.path()) + .progress_callback(callback); + + let svg_paths = render_sequences(&sequences, &config).unwrap(); + + assert_eq!(svg_paths.len(), 5); + + // Last progress should be 5/5 + let final_progress = last_progress.lock().unwrap(); + assert_eq!(*final_progress, (5, 5), "final progress should be 5/5"); +} diff --git a/morphology-img/tests/render.rs b/morphology-img/tests/render.rs index dc2c54a..b6538ab 100644 --- a/morphology-img/tests/render.rs +++ b/morphology-img/tests/render.rs @@ -314,6 +314,7 @@ fn test_render_multiple_svgs_batch() { &ly_files, output_dir.path(), Path::new("lilypond"), + None, ).unwrap(); // Verify all SVGs were created @@ -348,6 +349,7 @@ fn test_batch_render_preserves_order() { &ly_files, output_dir.path(), Path::new("lilypond"), + None, ).unwrap(); // Verify filenames are in order @@ -372,6 +374,7 @@ fn test_batch_render_empty_list() { &ly_files, output_dir.path(), Path::new("lilypond"), + None, ).unwrap(); assert_eq!(svg_paths.len(), 0, "should return empty vector for empty input"); @@ -396,6 +399,7 @@ fn test_batch_render_single_file() { &ly_files, output_dir.path(), Path::new("lilypond"), + None, ).unwrap(); assert_eq!(svg_paths.len(), 1); @@ -428,6 +432,7 @@ fn test_batch_render_stops_on_error() { &ly_files, output_dir.path(), Path::new("lilypond"), + None, ); // Should fail due to invalid file @@ -460,6 +465,7 @@ fn test_batch_render_many_files() { &ly_files, output_dir.path(), Path::new("lilypond"), + None, ).unwrap(); // Verify all 10 SVGs were created @@ -517,6 +523,7 @@ fn test_complete_pipeline_batch_rendering() { &ly_files, output_dir.path(), Path::new("lilypond"), + None, ).unwrap(); // Verify complete pipeline -- cgit v1.2.3