Skip to main content

sheetkit_core/
hyperlink.rs

1//! Hyperlink management for worksheet cells.
2//!
3//! Provides types and functions for setting, getting, and deleting hyperlinks
4//! on individual cells. Supports external URLs, internal sheet references,
5//! and email (mailto) links.
6
7use sheetkit_xml::relationships::{rel_types, Relationship, Relationships};
8use sheetkit_xml::worksheet::{Hyperlink, Hyperlinks, WorksheetXml};
9
10use std::collections::HashSet;
11
12use crate::error::{Error, Result};
13
14/// Type of hyperlink target.
15#[derive(Debug, Clone, PartialEq)]
16pub enum HyperlinkType {
17    /// External URL (e.g., `https://example.com` or `file:///path`).
18    External(String),
19    /// Internal sheet reference (e.g., "Sheet2!A1").
20    Internal(String),
21    /// Email link (e.g., "mailto:[email protected]").
22    Email(String),
23}
24
25/// Hyperlink information returned by get operations.
26#[derive(Debug, Clone, PartialEq)]
27pub struct HyperlinkInfo {
28    /// The hyperlink target.
29    pub link_type: HyperlinkType,
30    /// Optional display text.
31    pub display: Option<String>,
32    /// Optional tooltip text.
33    pub tooltip: Option<String>,
34}
35
36/// Set a hyperlink on a cell.
37///
38/// For external URLs and email links, a relationship entry is created in the
39/// worksheet `.rels` file with `TargetMode="External"`. For internal sheet
40/// references, only the `location` attribute is set on the hyperlink element
41/// (no relationship is needed).
42///
43/// If a hyperlink already exists on the cell, it is replaced.
44pub fn set_cell_hyperlink(
45    ws: &mut WorksheetXml,
46    rels: &mut Relationships,
47    cell: &str,
48    link: &HyperlinkType,
49    display: Option<&str>,
50    tooltip: Option<&str>,
51) -> Result<()> {
52    // Allocate before mutating so an allocation failure leaves state intact.
53    let new_rid = match link {
54        HyperlinkType::External(_) | HyperlinkType::Email(_) => Some(next_rel_id(ws, rels)?),
55        HyperlinkType::Internal(_) => None,
56    };
57
58    // Remove any existing hyperlink on this cell first.
59    delete_cell_hyperlink(ws, rels, cell)?;
60
61    let hyperlinks = ws
62        .hyperlinks
63        .get_or_insert_with(|| Hyperlinks { hyperlinks: vec![] });
64
65    match link {
66        HyperlinkType::External(url) | HyperlinkType::Email(url) => {
67            let rid = new_rid.ok_or_else(|| {
68                Error::Internal("hyperlink relationship ID was not allocated".to_string())
69            })?;
70            rels.relationships.push(Relationship {
71                id: rid.clone(),
72                rel_type: rel_types::HYPERLINK.to_string(),
73                target: url.clone(),
74                target_mode: Some("External".to_string()),
75            });
76            hyperlinks.hyperlinks.push(Hyperlink {
77                reference: cell.to_string(),
78                r_id: Some(rid),
79                location: None,
80                display: display.map(|s| s.to_string()),
81                tooltip: tooltip.map(|s| s.to_string()),
82            });
83        }
84        HyperlinkType::Internal(location) => {
85            hyperlinks.hyperlinks.push(Hyperlink {
86                reference: cell.to_string(),
87                r_id: None,
88                location: Some(location.clone()),
89                display: display.map(|s| s.to_string()),
90                tooltip: tooltip.map(|s| s.to_string()),
91            });
92        }
93    }
94
95    Ok(())
96}
97
98/// Get hyperlink information for a cell.
99///
100/// Returns `None` if the cell has no hyperlink.
101pub fn get_cell_hyperlink(
102    ws: &WorksheetXml,
103    rels: &Relationships,
104    cell: &str,
105) -> Result<Option<HyperlinkInfo>> {
106    let hyperlinks = match &ws.hyperlinks {
107        Some(h) => h,
108        None => return Ok(None),
109    };
110
111    let hl = match hyperlinks.hyperlinks.iter().find(|h| h.reference == cell) {
112        Some(h) => h,
113        None => return Ok(None),
114    };
115
116    let link_type = if let Some(ref rid) = hl.r_id {
117        // Look up the relationship target.
118        let rel = rels.relationships.iter().find(|r| r.id == *rid);
119        match rel {
120            Some(r) => {
121                let target = &r.target;
122                if target.starts_with("mailto:") {
123                    HyperlinkType::Email(target.clone())
124                } else {
125                    HyperlinkType::External(target.clone())
126                }
127            }
128            None => {
129                // Relationship not found; treat as external with empty target.
130                HyperlinkType::External(String::new())
131            }
132        }
133    } else if let Some(ref location) = hl.location {
134        HyperlinkType::Internal(location.clone())
135    } else {
136        // No r:id and no location; should not happen in valid files.
137        return Ok(None);
138    };
139
140    Ok(Some(HyperlinkInfo {
141        link_type,
142        display: hl.display.clone(),
143        tooltip: hl.tooltip.clone(),
144    }))
145}
146
147/// Delete a hyperlink from a cell.
148///
149/// Removes the hyperlink element from the worksheet XML. A hyperlink
150/// relationship it referenced is removed only when no remaining hyperlink
151/// still references it; relationships of other types are never removed.
152pub fn delete_cell_hyperlink(
153    ws: &mut WorksheetXml,
154    rels: &mut Relationships,
155    cell: &str,
156) -> Result<()> {
157    let hyperlinks = match &mut ws.hyperlinks {
158        Some(h) => h,
159        None => return Ok(()),
160    };
161
162    // Find and remove the hyperlink for this cell.
163    let removed: Vec<Hyperlink> = hyperlinks
164        .hyperlinks
165        .extract_if(.., |h| h.reference == cell)
166        .collect();
167
168    let still_referenced: HashSet<&str> = hyperlinks
169        .hyperlinks
170        .iter()
171        .filter_map(|h| h.r_id.as_deref())
172        .collect();
173    let orphaned: HashSet<&str> = removed
174        .iter()
175        .filter_map(|h| h.r_id.as_deref())
176        .filter(|rid| !still_referenced.contains(rid))
177        .collect();
178    if !orphaned.is_empty() {
179        rels.relationships
180            .retain(|r| !(orphaned.contains(r.id.as_str()) && r.rel_type == rel_types::HYPERLINK));
181    }
182
183    // If no hyperlinks remain, remove the container.
184    if hyperlinks.hyperlinks.is_empty() {
185        ws.hyperlinks = None;
186    }
187
188    Ok(())
189}
190
191/// Return the lowest unused `rId{n}` (n >= 1) for a worksheet rels collection.
192///
193/// IDs used by existing relationships and by hyperlink `r:id` references in
194/// the worksheet (including dangling ones) are skipped. Never overflows.
195fn next_rel_id(ws: &WorksheetXml, rels: &Relationships) -> Result<String> {
196    let hyperlink_rids = ws
197        .hyperlinks
198        .iter()
199        .flat_map(|h| h.hyperlinks.iter())
200        .filter_map(|h| h.r_id.as_deref());
201    let used: HashSet<u32> = rels
202        .relationships
203        .iter()
204        .map(|r| r.id.as_str())
205        .chain(hyperlink_rids)
206        .filter_map(|id| id.strip_prefix("rId").and_then(|n| n.parse::<u32>().ok()))
207        .collect();
208    (1..=u32::MAX)
209        .find(|n| !used.contains(n))
210        .map(|n| format!("rId{n}"))
211        .ok_or_else(|| {
212            Error::InvalidArgument("no unused worksheet relationship ID available".to_string())
213        })
214}
215
216#[cfg(test)]
217#[allow(clippy::field_reassign_with_default)]
218mod tests {
219    use super::*;
220    use sheetkit_xml::namespaces;
221
222    fn empty_rels() -> Relationships {
223        Relationships {
224            xmlns: namespaces::PACKAGE_RELATIONSHIPS.to_string(),
225            relationships: vec![],
226        }
227    }
228
229    #[test]
230    fn test_set_external_hyperlink() {
231        let mut ws = WorksheetXml::default();
232        let mut rels = empty_rels();
233
234        set_cell_hyperlink(
235            &mut ws,
236            &mut rels,
237            "A1",
238            &HyperlinkType::External("https://example.com".to_string()),
239            None,
240            None,
241        )
242        .unwrap();
243
244        // Hyperlink element should exist.
245        let hls = ws.hyperlinks.as_ref().unwrap();
246        assert_eq!(hls.hyperlinks.len(), 1);
247        assert_eq!(hls.hyperlinks[0].reference, "A1");
248        assert!(hls.hyperlinks[0].r_id.is_some());
249        assert!(hls.hyperlinks[0].location.is_none());
250
251        // Relationship should exist.
252        assert_eq!(rels.relationships.len(), 1);
253        assert_eq!(rels.relationships[0].target, "https://example.com");
254        assert_eq!(
255            rels.relationships[0].target_mode,
256            Some("External".to_string())
257        );
258        assert_eq!(rels.relationships[0].rel_type, rel_types::HYPERLINK);
259    }
260
261    #[test]
262    fn test_set_internal_hyperlink() {
263        let mut ws = WorksheetXml::default();
264        let mut rels = empty_rels();
265
266        set_cell_hyperlink(
267            &mut ws,
268            &mut rels,
269            "B2",
270            &HyperlinkType::Internal("Sheet2!A1".to_string()),
271            None,
272            None,
273        )
274        .unwrap();
275
276        let hls = ws.hyperlinks.as_ref().unwrap();
277        assert_eq!(hls.hyperlinks.len(), 1);
278        assert_eq!(hls.hyperlinks[0].reference, "B2");
279        assert!(hls.hyperlinks[0].r_id.is_none());
280        assert_eq!(hls.hyperlinks[0].location, Some("Sheet2!A1".to_string()));
281
282        // No relationship should be created for internal links.
283        assert!(rels.relationships.is_empty());
284    }
285
286    #[test]
287    fn test_set_email_hyperlink() {
288        let mut ws = WorksheetXml::default();
289        let mut rels = empty_rels();
290
291        set_cell_hyperlink(
292            &mut ws,
293            &mut rels,
294            "C3",
295            &HyperlinkType::Email("mailto:[email protected]".to_string()),
296            None,
297            None,
298        )
299        .unwrap();
300
301        let hls = ws.hyperlinks.as_ref().unwrap();
302        assert_eq!(hls.hyperlinks.len(), 1);
303        assert!(hls.hyperlinks[0].r_id.is_some());
304
305        assert_eq!(rels.relationships.len(), 1);
306        assert_eq!(rels.relationships[0].target, "mailto:[email protected]");
307        assert_eq!(
308            rels.relationships[0].target_mode,
309            Some("External".to_string())
310        );
311    }
312
313    #[test]
314    fn test_get_hyperlink_external() {
315        let mut ws = WorksheetXml::default();
316        let mut rels = empty_rels();
317
318        set_cell_hyperlink(
319            &mut ws,
320            &mut rels,
321            "A1",
322            &HyperlinkType::External("https://rust-lang.org".to_string()),
323            Some("Rust"),
324            Some("Visit Rust"),
325        )
326        .unwrap();
327
328        let info = get_cell_hyperlink(&ws, &rels, "A1").unwrap().unwrap();
329        assert_eq!(
330            info.link_type,
331            HyperlinkType::External("https://rust-lang.org".to_string())
332        );
333        assert_eq!(info.display, Some("Rust".to_string()));
334        assert_eq!(info.tooltip, Some("Visit Rust".to_string()));
335    }
336
337    #[test]
338    fn test_get_hyperlink_internal() {
339        let mut ws = WorksheetXml::default();
340        let mut rels = empty_rels();
341
342        set_cell_hyperlink(
343            &mut ws,
344            &mut rels,
345            "D4",
346            &HyperlinkType::Internal("Summary!B10".to_string()),
347            Some("Go to Summary"),
348            None,
349        )
350        .unwrap();
351
352        let info = get_cell_hyperlink(&ws, &rels, "D4").unwrap().unwrap();
353        assert_eq!(
354            info.link_type,
355            HyperlinkType::Internal("Summary!B10".to_string())
356        );
357        assert_eq!(info.display, Some("Go to Summary".to_string()));
358        assert!(info.tooltip.is_none());
359    }
360
361    #[test]
362    fn test_get_hyperlink_email() {
363        let mut ws = WorksheetXml::default();
364        let mut rels = empty_rels();
365
366        set_cell_hyperlink(
367            &mut ws,
368            &mut rels,
369            "A1",
370            &HyperlinkType::Email("mailto:[email protected]".to_string()),
371            None,
372            None,
373        )
374        .unwrap();
375
376        let info = get_cell_hyperlink(&ws, &rels, "A1").unwrap().unwrap();
377        assert_eq!(
378            info.link_type,
379            HyperlinkType::Email("mailto:[email protected]".to_string())
380        );
381    }
382
383    #[test]
384    fn test_delete_hyperlink() {
385        let mut ws = WorksheetXml::default();
386        let mut rels = empty_rels();
387
388        set_cell_hyperlink(
389            &mut ws,
390            &mut rels,
391            "A1",
392            &HyperlinkType::External("https://example.com".to_string()),
393            None,
394            None,
395        )
396        .unwrap();
397
398        assert!(ws.hyperlinks.is_some());
399        assert_eq!(rels.relationships.len(), 1);
400
401        delete_cell_hyperlink(&mut ws, &mut rels, "A1").unwrap();
402
403        // Hyperlinks container should be removed when empty.
404        assert!(ws.hyperlinks.is_none());
405        // Relationship should be cleaned up.
406        assert!(rels.relationships.is_empty());
407    }
408
409    #[test]
410    fn test_delete_internal_hyperlink() {
411        let mut ws = WorksheetXml::default();
412        let mut rels = empty_rels();
413
414        set_cell_hyperlink(
415            &mut ws,
416            &mut rels,
417            "A1",
418            &HyperlinkType::Internal("Sheet2!A1".to_string()),
419            None,
420            None,
421        )
422        .unwrap();
423
424        delete_cell_hyperlink(&mut ws, &mut rels, "A1").unwrap();
425
426        assert!(ws.hyperlinks.is_none());
427        assert!(rels.relationships.is_empty());
428    }
429
430    #[test]
431    fn test_hyperlink_with_display_and_tooltip() {
432        let mut ws = WorksheetXml::default();
433        let mut rels = empty_rels();
434
435        set_cell_hyperlink(
436            &mut ws,
437            &mut rels,
438            "A1",
439            &HyperlinkType::External("https://example.com".to_string()),
440            Some("Click here"),
441            Some("Opens example.com"),
442        )
443        .unwrap();
444
445        let hls = ws.hyperlinks.as_ref().unwrap();
446        assert_eq!(hls.hyperlinks[0].display, Some("Click here".to_string()));
447        assert_eq!(
448            hls.hyperlinks[0].tooltip,
449            Some("Opens example.com".to_string())
450        );
451
452        let info = get_cell_hyperlink(&ws, &rels, "A1").unwrap().unwrap();
453        assert_eq!(info.display, Some("Click here".to_string()));
454        assert_eq!(info.tooltip, Some("Opens example.com".to_string()));
455    }
456
457    #[test]
458    fn test_overwrite_hyperlink() {
459        let mut ws = WorksheetXml::default();
460        let mut rels = empty_rels();
461
462        // Set first hyperlink.
463        set_cell_hyperlink(
464            &mut ws,
465            &mut rels,
466            "A1",
467            &HyperlinkType::External("https://old.com".to_string()),
468            None,
469            None,
470        )
471        .unwrap();
472
473        // Overwrite with a new hyperlink.
474        set_cell_hyperlink(
475            &mut ws,
476            &mut rels,
477            "A1",
478            &HyperlinkType::External("https://new.com".to_string()),
479            Some("New Link"),
480            None,
481        )
482        .unwrap();
483
484        // Should have only one hyperlink.
485        let hls = ws.hyperlinks.as_ref().unwrap();
486        assert_eq!(hls.hyperlinks.len(), 1);
487
488        // Should have only one relationship (old one cleaned up).
489        assert_eq!(rels.relationships.len(), 1);
490        assert_eq!(rels.relationships[0].target, "https://new.com");
491
492        let info = get_cell_hyperlink(&ws, &rels, "A1").unwrap().unwrap();
493        assert_eq!(
494            info.link_type,
495            HyperlinkType::External("https://new.com".to_string())
496        );
497        assert_eq!(info.display, Some("New Link".to_string()));
498    }
499
500    #[test]
501    fn test_overwrite_external_with_internal() {
502        let mut ws = WorksheetXml::default();
503        let mut rels = empty_rels();
504
505        set_cell_hyperlink(
506            &mut ws,
507            &mut rels,
508            "A1",
509            &HyperlinkType::External("https://example.com".to_string()),
510            None,
511            None,
512        )
513        .unwrap();
514
515        assert_eq!(rels.relationships.len(), 1);
516
517        // Overwrite with internal link.
518        set_cell_hyperlink(
519            &mut ws,
520            &mut rels,
521            "A1",
522            &HyperlinkType::Internal("Sheet2!A1".to_string()),
523            None,
524            None,
525        )
526        .unwrap();
527
528        // Old relationship should be cleaned up.
529        assert!(rels.relationships.is_empty());
530
531        let hls = ws.hyperlinks.as_ref().unwrap();
532        assert_eq!(hls.hyperlinks.len(), 1);
533        assert!(hls.hyperlinks[0].r_id.is_none());
534        assert_eq!(hls.hyperlinks[0].location, Some("Sheet2!A1".to_string()));
535    }
536
537    #[test]
538    fn test_get_nonexistent_hyperlink() {
539        let ws = WorksheetXml::default();
540        let rels = empty_rels();
541
542        let result = get_cell_hyperlink(&ws, &rels, "Z99").unwrap();
543        assert!(result.is_none());
544    }
545
546    #[test]
547    fn test_get_nonexistent_hyperlink_with_empty_container() {
548        let mut ws = WorksheetXml::default();
549        ws.hyperlinks = Some(Hyperlinks { hyperlinks: vec![] });
550        let rels = empty_rels();
551
552        let result = get_cell_hyperlink(&ws, &rels, "A1").unwrap();
553        assert!(result.is_none());
554    }
555
556    #[test]
557    fn test_delete_nonexistent_hyperlink() {
558        let mut ws = WorksheetXml::default();
559        let mut rels = empty_rels();
560
561        // Deleting a hyperlink that does not exist should succeed silently.
562        delete_cell_hyperlink(&mut ws, &mut rels, "A1").unwrap();
563        assert!(ws.hyperlinks.is_none());
564    }
565
566    #[test]
567    fn test_multiple_hyperlinks() {
568        let mut ws = WorksheetXml::default();
569        let mut rels = empty_rels();
570
571        set_cell_hyperlink(
572            &mut ws,
573            &mut rels,
574            "A1",
575            &HyperlinkType::External("https://example.com".to_string()),
576            Some("Example"),
577            None,
578        )
579        .unwrap();
580
581        set_cell_hyperlink(
582            &mut ws,
583            &mut rels,
584            "B1",
585            &HyperlinkType::Internal("Sheet2!A1".to_string()),
586            Some("Sheet 2"),
587            None,
588        )
589        .unwrap();
590
591        set_cell_hyperlink(
592            &mut ws,
593            &mut rels,
594            "C1",
595            &HyperlinkType::Email("mailto:[email protected]".to_string()),
596            Some("Email Us"),
597            Some("Send email"),
598        )
599        .unwrap();
600
601        let hls = ws.hyperlinks.as_ref().unwrap();
602        assert_eq!(hls.hyperlinks.len(), 3);
603
604        // External and email should have relationships; internal should not.
605        assert_eq!(rels.relationships.len(), 2);
606
607        // Verify each hyperlink.
608        let a1 = get_cell_hyperlink(&ws, &rels, "A1").unwrap().unwrap();
609        assert_eq!(
610            a1.link_type,
611            HyperlinkType::External("https://example.com".to_string())
612        );
613        assert_eq!(a1.display, Some("Example".to_string()));
614
615        let b1 = get_cell_hyperlink(&ws, &rels, "B1").unwrap().unwrap();
616        assert_eq!(
617            b1.link_type,
618            HyperlinkType::Internal("Sheet2!A1".to_string())
619        );
620        assert_eq!(b1.display, Some("Sheet 2".to_string()));
621
622        let c1 = get_cell_hyperlink(&ws, &rels, "C1").unwrap().unwrap();
623        assert_eq!(
624            c1.link_type,
625            HyperlinkType::Email("mailto:[email protected]".to_string())
626        );
627        assert_eq!(c1.display, Some("Email Us".to_string()));
628        assert_eq!(c1.tooltip, Some("Send email".to_string()));
629    }
630
631    #[test]
632    fn test_delete_one_of_multiple() {
633        let mut ws = WorksheetXml::default();
634        let mut rels = empty_rels();
635
636        set_cell_hyperlink(
637            &mut ws,
638            &mut rels,
639            "A1",
640            &HyperlinkType::External("https://a.com".to_string()),
641            None,
642            None,
643        )
644        .unwrap();
645
646        set_cell_hyperlink(
647            &mut ws,
648            &mut rels,
649            "B1",
650            &HyperlinkType::External("https://b.com".to_string()),
651            None,
652            None,
653        )
654        .unwrap();
655
656        assert_eq!(ws.hyperlinks.as_ref().unwrap().hyperlinks.len(), 2);
657        assert_eq!(rels.relationships.len(), 2);
658
659        // Delete only A1.
660        delete_cell_hyperlink(&mut ws, &mut rels, "A1").unwrap();
661
662        let hls = ws.hyperlinks.as_ref().unwrap();
663        assert_eq!(hls.hyperlinks.len(), 1);
664        assert_eq!(hls.hyperlinks[0].reference, "B1");
665
666        // Only B1's relationship should remain.
667        assert_eq!(rels.relationships.len(), 1);
668        assert_eq!(rels.relationships[0].target, "https://b.com");
669    }
670
671    #[test]
672    fn test_next_rel_id_with_existing() {
673        let rels = Relationships {
674            xmlns: namespaces::PACKAGE_RELATIONSHIPS.to_string(),
675            relationships: vec![
676                Relationship {
677                    id: "rId1".to_string(),
678                    rel_type: rel_types::HYPERLINK.to_string(),
679                    target: "https://a.com".to_string(),
680                    target_mode: Some("External".to_string()),
681                },
682                Relationship {
683                    id: "rId3".to_string(),
684                    rel_type: rel_types::HYPERLINK.to_string(),
685                    target: "https://b.com".to_string(),
686                    target_mode: Some("External".to_string()),
687                },
688            ],
689        };
690        assert_eq!(
691            next_rel_id(&WorksheetXml::default(), &rels).unwrap(),
692            "rId2"
693        );
694    }
695    fn ext_rel(id: &str, target: &str) -> Relationship {
696        Relationship {
697            id: id.to_string(),
698            rel_type: rel_types::HYPERLINK.to_string(),
699            target: target.to_string(),
700            target_mode: Some("External".to_string()),
701        }
702    }
703
704    fn rid_hyperlink(cell: &str, rid: &str) -> Hyperlink {
705        Hyperlink {
706            reference: cell.to_string(),
707            r_id: Some(rid.to_string()),
708            location: None,
709            display: None,
710            tooltip: None,
711        }
712    }
713
714    #[test]
715    fn test_set_hyperlink_with_max_rid_does_not_overflow() {
716        let mut ws = WorksheetXml::default();
717        let mut rels = empty_rels();
718        rels.relationships.push(Relationship {
719            id: format!("rId{}", u32::MAX),
720            rel_type: rel_types::DRAWING.to_string(),
721            target: "../drawings/drawing1.xml".to_string(),
722            target_mode: None,
723        });
724
725        set_cell_hyperlink(
726            &mut ws,
727            &mut rels,
728            "A1",
729            &HyperlinkType::External("https://example.com".to_string()),
730            None,
731            None,
732        )
733        .unwrap();
734
735        assert_eq!(rels.relationships.len(), 2);
736        let new_rid = ws.hyperlinks.as_ref().unwrap().hyperlinks[0]
737            .r_id
738            .clone()
739            .unwrap();
740        assert_eq!(new_rid, "rId1");
741        assert_eq!(rels.relationships[0].rel_type, rel_types::DRAWING);
742        let info = get_cell_hyperlink(&ws, &rels, "A1").unwrap().unwrap();
743        assert_eq!(
744            info.link_type,
745            HyperlinkType::External("https://example.com".to_string())
746        );
747    }
748
749    #[test]
750    fn test_next_rel_id_skips_dangling_hyperlink_rids() {
751        let mut ws = WorksheetXml::default();
752        ws.hyperlinks = Some(Hyperlinks {
753            hyperlinks: vec![rid_hyperlink("A1", "rId1")],
754        });
755        let rels = empty_rels();
756        assert_eq!(next_rel_id(&ws, &rels).unwrap(), "rId2");
757    }
758
759    fn shared_rel_fixture() -> (WorksheetXml, Relationships) {
760        let mut ws = WorksheetXml::default();
761        ws.hyperlinks = Some(Hyperlinks {
762            hyperlinks: vec![rid_hyperlink("A1", "rId1"), rid_hyperlink("B1", "rId1")],
763        });
764        let mut rels = empty_rels();
765        rels.relationships
766            .push(ext_rel("rId1", "https://shared.com"));
767        (ws, rels)
768    }
769
770    #[test]
771    fn test_delete_hyperlink_keeps_shared_relationship() {
772        let (mut ws, mut rels) = shared_rel_fixture();
773
774        delete_cell_hyperlink(&mut ws, &mut rels, "A1").unwrap();
775
776        assert!(get_cell_hyperlink(&ws, &rels, "A1").unwrap().is_none());
777        let info = get_cell_hyperlink(&ws, &rels, "B1").unwrap().unwrap();
778        assert_eq!(
779            info.link_type,
780            HyperlinkType::External("https://shared.com".to_string())
781        );
782        assert_eq!(rels.relationships.len(), 1);
783
784        // Deleting the last reference removes the relationship.
785        delete_cell_hyperlink(&mut ws, &mut rels, "B1").unwrap();
786        assert!(rels.relationships.is_empty());
787        assert!(ws.hyperlinks.is_none());
788    }
789
790    #[test]
791    fn test_replace_hyperlink_keeps_shared_relationship() {
792        let (mut ws, mut rels) = shared_rel_fixture();
793
794        set_cell_hyperlink(
795            &mut ws,
796            &mut rels,
797            "A1",
798            &HyperlinkType::External("https://new.com".to_string()),
799            None,
800            None,
801        )
802        .unwrap();
803
804        let a1 = get_cell_hyperlink(&ws, &rels, "A1").unwrap().unwrap();
805        assert_eq!(
806            a1.link_type,
807            HyperlinkType::External("https://new.com".to_string())
808        );
809        let b1 = get_cell_hyperlink(&ws, &rels, "B1").unwrap().unwrap();
810        assert_eq!(
811            b1.link_type,
812            HyperlinkType::External("https://shared.com".to_string())
813        );
814        assert_eq!(rels.relationships.len(), 2);
815    }
816
817    #[test]
818    fn test_delete_hyperlink_keeps_non_hyperlink_relationship() {
819        let mut ws = WorksheetXml::default();
820        ws.hyperlinks = Some(Hyperlinks {
821            hyperlinks: vec![rid_hyperlink("A1", "rId1")],
822        });
823        let mut rels = empty_rels();
824        rels.relationships.push(Relationship {
825            id: "rId1".to_string(),
826            rel_type: rel_types::DRAWING.to_string(),
827            target: "../drawings/drawing1.xml".to_string(),
828            target_mode: None,
829        });
830
831        delete_cell_hyperlink(&mut ws, &mut rels, "A1").unwrap();
832
833        assert_eq!(rels.relationships.len(), 1);
834        assert_eq!(rels.relationships[0].rel_type, rel_types::DRAWING);
835    }
836}