1use 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#[derive(Debug, Clone, PartialEq)]
16pub enum HyperlinkType {
17 External(String),
19 Internal(String),
21 Email(String),
23}
24
25#[derive(Debug, Clone, PartialEq)]
27pub struct HyperlinkInfo {
28 pub link_type: HyperlinkType,
30 pub display: Option<String>,
32 pub tooltip: Option<String>,
34}
35
36pub 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 let new_rid = match link {
54 HyperlinkType::External(_) | HyperlinkType::Email(_) => Some(next_rel_id(ws, rels)?),
55 HyperlinkType::Internal(_) => None,
56 };
57
58 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
98pub 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 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 HyperlinkType::External(String::new())
131 }
132 }
133 } else if let Some(ref location) = hl.location {
134 HyperlinkType::Internal(location.clone())
135 } else {
136 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
147pub 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 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 hyperlinks.hyperlinks.is_empty() {
185 ws.hyperlinks = None;
186 }
187
188 Ok(())
189}
190
191fn 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 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 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 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 assert!(ws.hyperlinks.is_none());
405 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_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 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 let hls = ws.hyperlinks.as_ref().unwrap();
486 assert_eq!(hls.hyperlinks.len(), 1);
487
488 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 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 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 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 assert_eq!(rels.relationships.len(), 2);
606
607 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_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 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 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}