use morphology_img::template::{ get_template, get_format_ily, get_entry_ily, get_elements_ily, substitute_template }; use morphology_img::error::RenderError; #[test] fn test_embedded_templates_non_empty() { // Test that all embedded templates are non-empty assert!(!get_template().is_empty(), "template.ly should not be empty"); assert!(!get_format_ily().is_empty(), "format.ily should not be empty"); assert!(!get_entry_ily().is_empty(), "entry.ily should not be empty"); assert!(!get_elements_ily().is_empty(), "elements.ily should not be empty"); } #[test] fn test_template_contains_placeholder() { // Verify the template contains the placeholder let template = get_template(); assert!(template.contains("%%%"), "template should contain '%%%' placeholder"); } #[test] fn test_successful_substitution() { // Test successful substitution with simple markup let markup = "c'4 d'4 e'4"; let result = substitute_template(markup); assert!(result.is_ok(), "substitution should succeed"); let substituted = result.unwrap(); // Verify the markup is present in the result assert!(substituted.contains(markup), "result should contain the markup"); // Verify the placeholder is no longer present assert!(!substituted.contains("%%%"), "result should not contain placeholder"); // Verify the template structure is preserved assert!(substituted.contains(r#"\version "2.24.0""#), "version should be preserved"); assert!(substituted.contains(r#"\score"#), "score block should be preserved"); assert!(substituted.contains(r#"\entry"#), "entry should be preserved"); } #[test] fn test_substitution_with_empty_markup() { // Test with empty markup string let markup = ""; let result = substitute_template(markup); assert!(result.is_ok(), "substitution with empty string should succeed"); let substituted = result.unwrap(); // Placeholder should be replaced with empty string assert!(!substituted.contains("%%%")); } #[test] fn test_error_when_placeholder_missing() { // This test simulates what would happen if the placeholder was missing // We'll test this by creating a mock template without the placeholder // Note: We can't easily modify the embedded template at runtime, // so we'll just verify the error handling works as designed // by checking that our current template DOES have the placeholder let template = get_template(); if !template.contains("%%%") { // If this branch were taken, substitute_template would return an error let result = substitute_template("test"); assert!(result.is_err()); if let Err(RenderError::Template(msg)) = result { assert!(msg.contains("placeholder")); } else { panic!("Expected RenderError::Template"); } } else { // Current template has placeholder, which is correct assert!(template.contains("%%%")); } } #[test] fn test_template_structure() { // Verify the template has the expected structure let template = get_template(); assert!(template.contains(r#"\version"#), "should have version declaration"); assert!(template.contains(r#"\include "format.ily""#), "should include format.ily"); assert!(template.contains(r#"\include "elements.ily""#), "should include elements.ily"); assert!(template.contains(r#"\include "entry.ily""#), "should include entry.ily"); assert!(template.contains(r#"\score"#), "should have score block"); assert!(template.contains(r#"\entry"#), "should have entry block"); } #[test] fn test_substitution_preserves_whitespace() { // Test that substitution preserves indentation and whitespace let markup = "c'4 d'4"; let result = substitute_template(markup).unwrap(); // The indented structure should be preserved // The markup should be indented within the entry block assert!(result.contains(" \\entry")); } #[test] fn test_multiple_substitutions_independent() { // Test that multiple calls to substitute_template are independent let markup1 = "c'4 d'4"; let markup2 = "e'4 f'4"; let result1 = substitute_template(markup1).unwrap(); let result2 = substitute_template(markup2).unwrap(); assert!(result1.contains(markup1)); assert!(!result1.contains(markup2)); assert!(result2.contains(markup2)); assert!(!result2.contains(markup1)); } #[test] fn test_substitution_with_actual_sequence_markup() { // Test with markup that would come from the actual transformation pipeline // This is the example from the development plan let markup = "f'4 f4 e4 b4"; let result = substitute_template(markup); assert!(result.is_ok()); let substituted = result.unwrap(); // Verify it creates valid LilyPond syntax structure assert!(substituted.contains(r#"\entry { "#)); assert!(substituted.contains(markup)); assert!(substituted.contains("}")); // The substituted markup should be between the entry braces let entry_start = substituted.find(r#"\entry { "#).unwrap(); let markup_pos = substituted.find(markup).unwrap(); assert!(markup_pos > entry_start, "markup should be inside entry block"); }