test(ooxml): Sprint 9 - StyleSheet edge cases + relationship convenience tests

StyleSheet edge case tests (8 new):
- Circular reference detection (A→B→A)
- Self-reference detection (A→A)
- Deep inheritance chain (5 levels)
- Missing base style handling
- Empty chain for unknown styles
- is_heading and heading_level utilities
- Paragraph/table style iteration

Relationships convenience method tests (6 new):
- Various protocols (HTTP, FTP, mailto)
- Various image paths (relative, spaces)
- Query parameters with special chars
- Type constants validation
- Iterator filtering by type
- Empty target handling

266 tests total (up from 253)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: alanbld

crates/utf8dok-ooxml/src/relationships.rs

@@ -716,4 +716,125 @@ mod tests {
         assert_eq!(reparsed.get("rId1"), Some("path/with spaces/file.xml"));
         assert_eq!(reparsed.get("rId2"), Some("unicode/日本語/ファイル.xml"));
     }
+
+    // ==================== Sprint 9: Additional Edge Cases ====================
+
+    #[test]
+    fn test_add_hyperlink_various_protocols() {
+        let mut rels = Relationships::new();
+
+        // Standard HTTP
+        let http_id = rels.add_hyperlink("https://example.com/page");
+        assert!(rels.is_hyperlink(&http_id));
+
+        // FTP protocol
+        let ftp_id = rels.add_hyperlink("ftp://files.example.com/download.zip");
+        assert!(rels.is_hyperlink(&ftp_id));
+
+        // Mailto link
+        let mail_id = rels.add_hyperlink("mailto:user@example.com");
+        assert!(rels.is_hyperlink(&mail_id));
+
+        // Verify all are retrievable
+        assert_eq!(rels.get(&http_id), Some("https://example.com/page"));
+        assert_eq!(rels.get(&ftp_id), Some("ftp://files.example.com/download.zip"));
+        assert_eq!(rels.get(&mail_id), Some("mailto:user@example.com"));
+    }
+
+    #[test]
+    fn test_add_image_various_paths() {
+        let mut rels = Relationships::new();
+
+        // Standard media path
+        let id1 = rels.add_image("media/image1.png");
+        assert_eq!(rels.get(&id1), Some("media/image1.png"));
+
+        // Relative path with ..
+        let id2 = rels.add_image("../media/image2.jpg");
+        assert_eq!(rels.get(&id2), Some("../media/image2.jpg"));
+
+        // Path with spaces
+        let id3 = rels.add_image("media/my image.png");
+        assert_eq!(rels.get(&id3), Some("media/my image.png"));
+
+        // All should be images
+        assert!(rels.is_image(&id1));
+        assert!(rels.is_image(&id2));
+        assert!(rels.is_image(&id3));
+    }
+
+    #[test]
+    fn test_hyperlink_with_query_params() {
+        let mut rels = Relationships::new();
+
+        // URL with query parameters containing special chars
+        let url = "https://example.com/search?q=test&page=1&filter=a<b";
+        let id = rels.add_hyperlink(url);
+
+        // Should store the URL as-is
+        assert_eq!(rels.get(&id), Some(url));
+
+        // Should serialize and parse correctly
+        let xml = rels.to_xml();
+        let reparsed = Relationships::parse(xml.as_bytes()).unwrap();
+        assert_eq!(reparsed.get(&id), Some(url));
+    }
+
+    #[test]
+    fn test_relationship_type_constants() {
+        // Verify all type constants are valid URIs
+        assert!(Relationships::TYPE_STYLES.starts_with("http://"));
+        assert!(Relationships::TYPE_NUMBERING.starts_with("http://"));
+        assert!(Relationships::TYPE_SETTINGS.starts_with("http://"));
+        assert!(Relationships::TYPE_FONT_TABLE.starts_with("http://"));
+        assert!(Relationships::TYPE_IMAGE.starts_with("http://"));
+        assert!(Relationships::TYPE_HYPERLINK.starts_with("http://"));
+
+        // Verify constants are unique
+        let types = [
+            Relationships::TYPE_STYLES,
+            Relationships::TYPE_NUMBERING,
+            Relationships::TYPE_SETTINGS,
+            Relationships::TYPE_FONT_TABLE,
+            Relationships::TYPE_IMAGE,
+            Relationships::TYPE_HYPERLINK,
+        ];
+        let unique: std::collections::HashSet<_> = types.iter().collect();
+        assert_eq!(unique.len(), types.len(), "All type constants should be unique");
+    }
+
+    #[test]
+    fn test_iter_with_type_filter() {
+        let mut rels = Relationships::new();
+
+        rels.add_image("media/img1.png");
+        rels.add_image("media/img2.jpg");
+        rels.add_hyperlink("https://example.com");
+        rels.add("styles.xml".to_string(), Relationships::TYPE_STYLES.to_string());
+
+        // Count by type
+        let image_count = rels.iter()
+            .filter(|(_, rel)| rel.rel_type == Relationships::TYPE_IMAGE)
+            .count();
+        let link_count = rels.iter()
+            .filter(|(_, rel)| rel.rel_type == Relationships::TYPE_HYPERLINK)
+            .count();
+
+        assert_eq!(image_count, 2);
+        assert_eq!(link_count, 1);
+    }
+
+    #[test]
+    fn test_empty_target_handling() {
+        let mut rels = Relationships::new();
+
+        // Add relationship with empty target (edge case)
+        let id = rels.add(String::new(), "type".to_string());
+        assert_eq!(rels.get(&id), Some(""));
+
+        // Should serialize and parse correctly
+        let xml = rels.to_xml();
+        let reparsed = Relationships::parse(xml.as_bytes()).unwrap();
+        assert_eq!(reparsed.get(&id), Some(""));
+    }
 }

crates/utf8dok-ooxml/src/styles.rs

@@ -751,4 +751,188 @@ mod tests {
         assert!(!styles.get("CompanyHeader").unwrap().builtin);
         assert!(!styles.get("LegalDisclaimer").unwrap().builtin);
     }
+
+    // ==================== Sprint 9: StyleSheet Edge Cases ====================
+
+    #[test]
+    fn test_resolve_chain_circular_reference() {
+        // Create styles with circular inheritance: A→B→A
+        let xml = br#"<?xml version="1.0" encoding="UTF-8"?>
+        <w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+            <w:style w:type="paragraph" w:styleId="StyleA">
+                <w:name w:val="Style A"/>
+                <w:basedOn w:val="StyleB"/>
+            </w:style>
+            <w:style w:type="paragraph" w:styleId="StyleB">
+                <w:name w:val="Style B"/>
+                <w:basedOn w:val="StyleA"/>
+            </w:style>
+        </w:styles>"#;
+
+        let styles = StyleSheet::parse(xml).unwrap();
+
+        // Should not panic or loop forever - breaks at cycle detection
+        let chain = styles.resolve_chain("StyleA");
+
+        // Chain should contain at most both styles (breaks at seen check)
+        assert!(chain.len() <= 2);
+        assert_eq!(chain[0].id, "StyleA");
+    }
+
+    #[test]
+    fn test_resolve_chain_self_reference() {
+        // Create a style that references itself
+        let xml = br#"<?xml version="1.0" encoding="UTF-8"?>
+        <w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+            <w:style w:type="paragraph" w:styleId="SelfRef">
+                <w:name w:val="Self Reference"/>
+                <w:basedOn w:val="SelfRef"/>
+            </w:style>
+        </w:styles>"#;
+
+        let styles = StyleSheet::parse(xml).unwrap();
+
+        // Should not loop - breaks immediately on self-reference
+        let chain = styles.resolve_chain("SelfRef");
+
+        assert_eq!(chain.len(), 1);
+        assert_eq!(chain[0].id, "SelfRef");
+    }
+
+    #[test]
+    fn test_resolve_chain_deep_inheritance() {
+        // Create a deep inheritance chain: A→B→C→D→E
+        let xml = br#"<?xml version="1.0" encoding="UTF-8"?>
+        <w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+            <w:style w:type="paragraph" w:styleId="StyleA">
+                <w:name w:val="Style A"/>
+                <w:basedOn w:val="StyleB"/>
+            </w:style>
+            <w:style w:type="paragraph" w:styleId="StyleB">
+                <w:name w:val="Style B"/>
+                <w:basedOn w:val="StyleC"/>
+            </w:style>
+            <w:style w:type="paragraph" w:styleId="StyleC">
+                <w:name w:val="Style C"/>
+                <w:basedOn w:val="StyleD"/>
+            </w:style>
+            <w:style w:type="paragraph" w:styleId="StyleD">
+                <w:name w:val="Style D"/>
+                <w:basedOn w:val="StyleE"/>
+            </w:style>
+            <w:style w:type="paragraph" w:styleId="StyleE">
+                <w:name w:val="Style E"/>
+            </w:style>
+        </w:styles>"#;
+
+        let styles = StyleSheet::parse(xml).unwrap();
+
+        let chain = styles.resolve_chain("StyleA");
+
+        // Should resolve entire chain
+        assert_eq!(chain.len(), 5);
+        assert_eq!(chain[0].id, "StyleA");
+        assert_eq!(chain[1].id, "StyleB");
+        assert_eq!(chain[2].id, "StyleC");
+        assert_eq!(chain[3].id, "StyleD");
+        assert_eq!(chain[4].id, "StyleE");
+    }
+
+    #[test]
+    fn test_resolve_chain_missing_base() {
+        // Style references a base that doesn't exist
+        let xml = br#"<?xml version="1.0" encoding="UTF-8"?>
+        <w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+            <w:style w:type="paragraph" w:styleId="Orphan">
+                <w:name w:val="Orphan Style"/>
+                <w:basedOn w:val="NonExistent"/>
+            </w:style>
+        </w:styles>"#;
+
+        let styles = StyleSheet::parse(xml).unwrap();
+
+        let chain = styles.resolve_chain("Orphan");
+
+        // Should only contain the orphan style (base not found)
+        assert_eq!(chain.len(), 1);
+        assert_eq!(chain[0].id, "Orphan");
+        assert_eq!(chain[0].based_on, Some("NonExistent".to_string()));
+    }
+
+    #[test]
+    fn test_resolve_chain_empty_for_unknown() {
+        let xml = br#"<?xml version="1.0" encoding="UTF-8"?>
+        <w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+            <w:style w:type="paragraph" w:styleId="Normal">
+                <w:name w:val="Normal"/>
+            </w:style>
+        </w:styles>"#;
+
+        let styles = StyleSheet::parse(xml).unwrap();
+
+        // Unknown style returns empty chain
+        let chain = styles.resolve_chain("DoesNotExist");
+        assert!(chain.is_empty());
+    }
+
+    #[test]
+    fn test_is_heading_and_level() {
+        let xml = br#"<?xml version="1.0" encoding="UTF-8"?>
+        <w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+            <w:style w:type="paragraph" w:styleId="Heading1">
+                <w:name w:val="Heading 1"/>
+                <w:pPr>
+                    <w:outlineLvl w:val="0"/>
+                </w:pPr>
+            </w:style>
+            <w:style w:type="paragraph" w:styleId="Heading3">
+                <w:name w:val="Heading 3"/>
+                <w:pPr>
+                    <w:outlineLvl w:val="2"/>
+                </w:pPr>
+            </w:style>
+            <w:style w:type="paragraph" w:styleId="Normal">
+                <w:name w:val="Normal"/>
+            </w:style>
+        </w:styles>"#;
+
+        let styles = StyleSheet::parse(xml).unwrap();
+
+        assert!(styles.is_heading("Heading1"));
+        assert!(styles.is_heading("Heading3"));
+        assert!(!styles.is_heading("Normal"));
+        assert!(!styles.is_heading("Unknown"));
+
+        assert_eq!(styles.heading_level("Heading1"), Some(1));
+        assert_eq!(styles.heading_level("Heading3"), Some(3));
+        assert_eq!(styles.heading_level("Normal"), None);
+        assert_eq!(styles.heading_level("Unknown"), None);
+    }
+
+    #[test]
+    fn test_stylesheet_iteration() {
+        let xml = br#"<?xml version="1.0" encoding="UTF-8"?>
+        <w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+            <w:style w:type="paragraph" w:styleId="Para1">
+                <w:name w:val="Paragraph 1"/>
+            </w:style>
+            <w:style w:type="table" w:styleId="Table1">
+                <w:name w:val="Table 1"/>
+            </w:style>
+            <w:style w:type="paragraph" w:styleId="Para2">
+                <w:name w:val="Paragraph 2"/>
+            </w:style>
+        </w:styles>"#;
+
+        let styles = StyleSheet::parse(xml).unwrap();
+
+        // Test paragraph iteration
+        let para_styles: Vec<_> = styles.paragraph_styles().collect();
+        assert_eq!(para_styles.len(), 2);
+
+        // Test table iteration
+        let table_styles: Vec<_> = styles.table_styles().collect();
+        assert_eq!(table_styles.len(), 1);
+        assert_eq!(table_styles[0].id, "Table1");
+    }
 }