ddex-parser 0.4.5

//! Integration test to verify public API works with streaming implementation

#[cfg(test)]
mod tests {
    use crate::streaming::WorkingStreamingElement;
    use crate::{DDEXParser, ERNVersion};
    use std::io::Cursor;

    #[test]
    fn test_public_streaming_api() {
        let xml = r#"<?xml version="1.0" encoding="UTF-8"?>
<ern:NewReleaseMessage xmlns:ern="http://ddex.net/xml/ern/43">
    <MessageHeader>
        <MessageId>API-TEST-MSG</MessageId>
        <CreatedDateTime>2023-01-01T00:00:00Z</CreatedDateTime>
    </MessageHeader>
    <Release ReleaseReference="API-REL-001">
        <ReferenceTitle>
            <TitleText>Public API Test Release</TitleText>
        </ReferenceTitle>
    </Release>
    <SoundRecording ResourceReference="API-RES-001">
        <ReferenceTitle>
            <TitleText>Public API Test Track</TitleText>
        </ReferenceTitle>
        <Duration>PT4M32S</Duration>
        <ResourceId>
            <ISRC>USAPI1234567</ISRC>
        </ResourceId>
    </SoundRecording>
</ern:NewReleaseMessage>"#;

        let parser = DDEXParser::new();
        let cursor = Cursor::new(xml.as_bytes());

        // Test the public streaming API
        let stream_iterator = parser.stream(cursor);
        let elements: Result<Vec<_>, _> = stream_iterator.collect();

        assert!(elements.is_ok(), "Public streaming API should work");
        let elements = elements.unwrap();

        println!("Public API - Elements found: {}", elements.len());

        // Verify we got the expected elements
        let headers = elements
            .iter()
            .filter(|e| matches!(e, WorkingStreamingElement::MessageHeader { .. }))
            .count();
        let releases = elements
            .iter()
            .filter(|e| matches!(e, WorkingStreamingElement::Release { .. }))
            .count();
        let recordings = elements
            .iter()
            .filter(|e| matches!(e, WorkingStreamingElement::SoundRecording { .. }))
            .count();

        assert!(headers >= 1, "Should find at least 1 message header");
        assert!(releases >= 1, "Should find at least 1 release");
        assert!(recordings >= 1, "Should find at least 1 sound recording");

        // Test specific content
        if let Some(WorkingStreamingElement::Release {
            reference, title, ..
        }) = elements
            .iter()
            .find(|e| matches!(e, WorkingStreamingElement::Release { .. }))
        {
            assert_eq!(
                reference, "API-REL-001",
                "Release reference should be correct"
            );
            assert_eq!(
                title, "Public API Test Release",
                "Release title should be correct"
            );
        }

        if let Some(WorkingStreamingElement::SoundRecording {
            reference,
            title,
            duration,
            isrc,
            ..
        }) = elements
            .iter()
            .find(|e| matches!(e, WorkingStreamingElement::SoundRecording { .. }))
        {
            assert_eq!(
                reference, "API-RES-001",
                "Resource reference should be correct"
            );
            assert_eq!(
                title, "Public API Test Track",
                "Resource title should be correct"
            );
            assert_eq!(
                duration,
                &Some("PT4M32S".to_string()),
                "Duration should be correct"
            );
            assert_eq!(
                isrc,
                &Some("USAPI1234567".to_string()),
                "ISRC should be correct"
            );
        }

        println!("✅ Public streaming API integration test passed!");
    }

    #[test]
    fn test_streaming_with_version_detection() {
        let xml = r#"<?xml version="1.0" encoding="UTF-8"?>
<ern:NewReleaseMessage xmlns:ern="http://ddex.net/xml/ern/42">
    <MessageHeader>
        <MessageId>VERSION-TEST-MSG</MessageId>
    </MessageHeader>
</ern:NewReleaseMessage>"#;

        let parser = DDEXParser::new();
        let cursor = Cursor::new(xml.as_bytes());

        // Test version detection (this will fall back if detector doesn't work)
        let result = parser.stream_with_version_detection(cursor);

        // Even if version detection fails, the streaming should work
        if let Ok(stream_iterator) = result {
            let elements: Result<Vec<_>, _> = stream_iterator.collect();
            assert!(elements.is_ok(), "Version detection streaming should work");

            let elements = elements.unwrap();
            assert!(
                elements.len() >= 1,
                "Should find at least end-of-stream element"
            );
        } else {
            // If version detection fails, at least verify the error is reasonable
            println!(
                "Version detection failed as expected (detector may not be fully implemented)"
            );
        }

        println!("✅ Version detection API test completed!");
    }

    #[test]
    fn test_streaming_statistics() {
        let xml = r#"<?xml version="1.0" encoding="UTF-8"?>
<ern:NewReleaseMessage xmlns:ern="http://ddex.net/xml/ern/43">
    <MessageHeader><MessageId>STATS-TEST</MessageId></MessageHeader>
    <Release ReleaseReference="STATS-REL"><ReferenceTitle><TitleText>Stats Test</TitleText></ReferenceTitle></Release>
</ern:NewReleaseMessage>"#;

        let parser = DDEXParser::new();
        let cursor = Cursor::new(xml.as_bytes());
        let mut stream_iterator = parser.stream(cursor);

        // Process a few elements
        let _first = stream_iterator.next();
        let _second = stream_iterator.next();

        // Check statistics
        let stats = stream_iterator.stats();
        assert!(
            stats.bytes_processed > 0,
            "Should have processed some bytes"
        );
        assert!(
            stats.elapsed_time.as_nanos() > 0,
            "Should have elapsed time"
        );

        println!(
            "Statistics: {} bytes processed, {:.2} MB/s throughput",
            stats.bytes_processed, stats.throughput_mb_per_sec
        );
        println!("✅ Streaming statistics API test passed!");
    }
}