Skip to main content

sheetkit_xml/
workbook.rs

1//! Workbook XML schema structures.
2//!
3//! Represents `xl/workbook.xml` in the OOXML package.
4
5use serde::{Deserialize, Serialize};
6
7use crate::namespaces;
8
9/// Workbook root element (`xl/workbook.xml`).
10#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11#[serde(rename = "workbook")]
12pub struct WorkbookXml {
13    #[serde(rename = "@xmlns", default = "crate::default_spreadsheet_ml_ns")]
14    pub xmlns: String,
15
16    #[serde(rename = "@xmlns:r", default = "crate::default_relationships_ns")]
17    pub xmlns_r: String,
18
19    #[serde(rename = "fileVersion", skip_serializing_if = "Option::is_none")]
20    pub file_version: Option<FileVersion>,
21
22    #[serde(rename = "fileSharing", skip_serializing_if = "Option::is_none")]
23    pub file_sharing: Option<FileSharing>,
24
25    #[serde(rename = "workbookPr", skip_serializing_if = "Option::is_none")]
26    pub workbook_pr: Option<WorkbookPr>,
27
28    #[serde(rename = "workbookProtection", skip_serializing_if = "Option::is_none")]
29    pub workbook_protection: Option<WorkbookProtection>,
30
31    #[serde(rename = "bookViews", skip_serializing_if = "Option::is_none")]
32    pub book_views: Option<BookViews>,
33
34    #[serde(rename = "sheets")]
35    pub sheets: Sheets,
36
37    #[serde(rename = "externalReferences", skip_serializing_if = "Option::is_none")]
38    pub external_references: Option<ExternalReferences>,
39
40    #[serde(rename = "definedNames", skip_serializing_if = "Option::is_none")]
41    pub defined_names: Option<DefinedNames>,
42
43    #[serde(rename = "calcPr", skip_serializing_if = "Option::is_none")]
44    pub calc_pr: Option<CalcPr>,
45
46    #[serde(rename = "oleSize", skip_serializing_if = "Option::is_none")]
47    pub ole_size: Option<OleSize>,
48
49    #[serde(rename = "pivotCaches", skip_serializing_if = "Option::is_none")]
50    pub pivot_caches: Option<PivotCaches>,
51}
52
53/// File version information.
54#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
55pub struct FileVersion {
56    #[serde(rename = "@appName", skip_serializing_if = "Option::is_none")]
57    pub app_name: Option<String>,
58
59    #[serde(rename = "@lastEdited", skip_serializing_if = "Option::is_none")]
60    pub last_edited: Option<String>,
61
62    #[serde(rename = "@lowestEdited", skip_serializing_if = "Option::is_none")]
63    pub lowest_edited: Option<String>,
64
65    #[serde(rename = "@rupBuild", skip_serializing_if = "Option::is_none")]
66    pub rup_build: Option<String>,
67}
68
69/// Workbook file-sharing settings.
70#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
71pub struct FileSharing {
72    #[serde(
73        rename = "@readOnlyRecommended",
74        skip_serializing_if = "Option::is_none"
75    )]
76    pub read_only_recommended: Option<bool>,
77
78    #[serde(rename = "@userName", skip_serializing_if = "Option::is_none")]
79    pub user_name: Option<String>,
80
81    #[serde(
82        rename = "@reservationPassword",
83        skip_serializing_if = "Option::is_none"
84    )]
85    pub reservation_password: Option<String>,
86
87    #[serde(rename = "@algorithmName", skip_serializing_if = "Option::is_none")]
88    pub algorithm_name: Option<String>,
89
90    #[serde(rename = "@hashValue", skip_serializing_if = "Option::is_none")]
91    pub hash_value: Option<String>,
92
93    #[serde(rename = "@saltValue", skip_serializing_if = "Option::is_none")]
94    pub salt_value: Option<String>,
95
96    #[serde(rename = "@spinCount", skip_serializing_if = "Option::is_none")]
97    pub spin_count: Option<u32>,
98}
99
100/// Workbook properties.
101#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
102pub struct WorkbookPr {
103    #[serde(rename = "@date1904", skip_serializing_if = "Option::is_none")]
104    pub date1904: Option<bool>,
105
106    #[serde(rename = "@dateCompatibility", skip_serializing_if = "Option::is_none")]
107    pub date_compatibility: Option<bool>,
108
109    #[serde(rename = "@filterPrivacy", skip_serializing_if = "Option::is_none")]
110    pub filter_privacy: Option<bool>,
111
112    #[serde(
113        rename = "@defaultThemeVersion",
114        skip_serializing_if = "Option::is_none"
115    )]
116    pub default_theme_version: Option<u32>,
117
118    #[serde(rename = "@showObjects", skip_serializing_if = "Option::is_none")]
119    pub show_objects: Option<String>,
120
121    #[serde(rename = "@backupFile", skip_serializing_if = "Option::is_none")]
122    pub backup_file: Option<bool>,
123
124    #[serde(rename = "@codeName", skip_serializing_if = "Option::is_none")]
125    pub code_name: Option<String>,
126
127    #[serde(
128        rename = "@checkCompatibility",
129        skip_serializing_if = "Option::is_none"
130    )]
131    pub check_compatibility: Option<bool>,
132
133    #[serde(
134        rename = "@autoCompressPictures",
135        skip_serializing_if = "Option::is_none"
136    )]
137    pub auto_compress_pictures: Option<bool>,
138
139    #[serde(
140        rename = "@refreshAllConnections",
141        skip_serializing_if = "Option::is_none"
142    )]
143    pub refresh_all_connections: Option<bool>,
144
145    #[serde(
146        rename = "@saveExternalLinkValues",
147        skip_serializing_if = "Option::is_none"
148    )]
149    pub save_external_link_values: Option<bool>,
150
151    #[serde(rename = "@updateLinks", skip_serializing_if = "Option::is_none")]
152    pub update_links: Option<String>,
153
154    #[serde(
155        rename = "@hidePivotFieldList",
156        skip_serializing_if = "Option::is_none"
157    )]
158    pub hide_pivot_field_list: Option<bool>,
159
160    #[serde(
161        rename = "@showPivotChartFilter",
162        skip_serializing_if = "Option::is_none"
163    )]
164    pub show_pivot_chart_filter: Option<bool>,
165
166    #[serde(rename = "@allowRefreshQuery", skip_serializing_if = "Option::is_none")]
167    pub allow_refresh_query: Option<bool>,
168
169    #[serde(rename = "@publishItems", skip_serializing_if = "Option::is_none")]
170    pub publish_items: Option<bool>,
171
172    #[serde(
173        rename = "@showBorderUnselectedTables",
174        skip_serializing_if = "Option::is_none"
175    )]
176    pub show_border_unselected_tables: Option<bool>,
177
178    #[serde(rename = "@promptedSolutions", skip_serializing_if = "Option::is_none")]
179    pub prompted_solutions: Option<bool>,
180
181    #[serde(rename = "@showInkAnnotation", skip_serializing_if = "Option::is_none")]
182    pub show_ink_annotation: Option<bool>,
183}
184
185/// Book views container.
186#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
187pub struct BookViews {
188    #[serde(rename = "workbookView")]
189    pub workbook_views: Vec<WorkbookView>,
190}
191
192/// Individual workbook view.
193#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
194pub struct WorkbookView {
195    #[serde(rename = "@xWindow", skip_serializing_if = "Option::is_none")]
196    pub x_window: Option<i32>,
197
198    #[serde(rename = "@yWindow", skip_serializing_if = "Option::is_none")]
199    pub y_window: Option<i32>,
200
201    #[serde(rename = "@windowWidth", skip_serializing_if = "Option::is_none")]
202    pub window_width: Option<u32>,
203
204    #[serde(rename = "@windowHeight", skip_serializing_if = "Option::is_none")]
205    pub window_height: Option<u32>,
206
207    #[serde(rename = "@activeTab", skip_serializing_if = "Option::is_none")]
208    pub active_tab: Option<u32>,
209}
210
211/// Sheets container.
212#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
213pub struct Sheets {
214    #[serde(rename = "sheet")]
215    pub sheets: Vec<SheetEntry>,
216}
217
218/// Container for external workbook references.
219#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
220pub struct ExternalReferences {
221    #[serde(rename = "externalReference", default)]
222    pub references: Vec<ExternalReference>,
223}
224
225/// Relationship to an external workbook reference.
226#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
227pub struct ExternalReference {
228    #[serde(rename = "@r:id", alias = "@id")]
229    pub r_id: String,
230}
231
232/// Individual sheet entry in the workbook.
233#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
234pub struct SheetEntry {
235    #[serde(rename = "@name")]
236    pub name: String,
237
238    #[serde(rename = "@sheetId")]
239    pub sheet_id: u32,
240
241    #[serde(rename = "@state", skip_serializing_if = "Option::is_none")]
242    pub state: Option<String>,
243
244    #[serde(rename = "@r:id", alias = "@id")]
245    pub r_id: String,
246}
247
248/// Defined names container.
249#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
250pub struct DefinedNames {
251    #[serde(rename = "definedName", default)]
252    pub defined_names: Vec<DefinedName>,
253}
254
255/// Individual defined name.
256#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
257pub struct DefinedName {
258    #[serde(rename = "@name")]
259    pub name: String,
260
261    #[serde(rename = "@localSheetId", skip_serializing_if = "Option::is_none")]
262    pub local_sheet_id: Option<u32>,
263
264    #[serde(rename = "@comment", skip_serializing_if = "Option::is_none")]
265    pub comment: Option<String>,
266
267    #[serde(rename = "@hidden", skip_serializing_if = "Option::is_none")]
268    pub hidden: Option<bool>,
269
270    /// The formula/reference value (element text content).
271    #[serde(rename = "$value")]
272    pub value: String,
273}
274
275/// Workbook-level protection settings.
276#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
277pub struct WorkbookProtection {
278    #[serde(rename = "@workbookPassword", skip_serializing_if = "Option::is_none")]
279    pub workbook_password: Option<String>,
280
281    #[serde(rename = "@lockStructure", skip_serializing_if = "Option::is_none")]
282    pub lock_structure: Option<bool>,
283
284    #[serde(rename = "@lockWindows", skip_serializing_if = "Option::is_none")]
285    pub lock_windows: Option<bool>,
286
287    #[serde(rename = "@revisionsPassword", skip_serializing_if = "Option::is_none")]
288    pub revisions_password: Option<String>,
289
290    #[serde(rename = "@lockRevision", skip_serializing_if = "Option::is_none")]
291    pub lock_revision: Option<bool>,
292}
293
294/// Calculation properties.
295#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
296pub struct CalcPr {
297    #[serde(rename = "@calcId", skip_serializing_if = "Option::is_none")]
298    pub calc_id: Option<u32>,
299
300    #[serde(rename = "@calcMode", skip_serializing_if = "Option::is_none")]
301    pub calc_mode: Option<String>,
302
303    #[serde(rename = "@fullCalcOnLoad", skip_serializing_if = "Option::is_none")]
304    pub full_calc_on_load: Option<bool>,
305
306    #[serde(rename = "@refMode", skip_serializing_if = "Option::is_none")]
307    pub ref_mode: Option<String>,
308
309    #[serde(rename = "@iterate", skip_serializing_if = "Option::is_none")]
310    pub iterate: Option<bool>,
311
312    #[serde(rename = "@iterateCount", skip_serializing_if = "Option::is_none")]
313    pub iterate_count: Option<u32>,
314
315    #[serde(rename = "@iterateDelta", skip_serializing_if = "Option::is_none")]
316    pub iterate_delta: Option<f64>,
317
318    #[serde(rename = "@fullPrecision", skip_serializing_if = "Option::is_none")]
319    pub full_precision: Option<bool>,
320
321    #[serde(rename = "@calcCompleted", skip_serializing_if = "Option::is_none")]
322    pub calc_completed: Option<bool>,
323
324    #[serde(rename = "@calcOnSave", skip_serializing_if = "Option::is_none")]
325    pub calc_on_save: Option<bool>,
326
327    #[serde(rename = "@concurrentCalc", skip_serializing_if = "Option::is_none")]
328    pub concurrent_calc: Option<bool>,
329
330    #[serde(
331        rename = "@concurrentManualCount",
332        skip_serializing_if = "Option::is_none"
333    )]
334    pub concurrent_manual_count: Option<u32>,
335
336    #[serde(rename = "@forceFullCalc", skip_serializing_if = "Option::is_none")]
337    pub force_full_calc: Option<bool>,
338}
339
340/// Range occupied by embedded OLE objects.
341#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
342pub struct OleSize {
343    #[serde(rename = "@ref")]
344    pub reference: String,
345}
346
347/// Container for pivot cache references in the workbook.
348#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
349pub struct PivotCaches {
350    #[serde(rename = "pivotCache", default)]
351    pub caches: Vec<PivotCacheEntry>,
352}
353
354/// Individual pivot cache entry linking a cache ID to a relationship.
355#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
356pub struct PivotCacheEntry {
357    #[serde(rename = "@cacheId")]
358    pub cache_id: u32,
359
360    #[serde(rename = "@r:id", alias = "@id")]
361    pub r_id: String,
362}
363
364impl Default for WorkbookXml {
365    fn default() -> Self {
366        Self {
367            xmlns: namespaces::SPREADSHEET_ML.to_string(),
368            xmlns_r: namespaces::RELATIONSHIPS.to_string(),
369            file_version: None,
370            file_sharing: None,
371            workbook_pr: None,
372            workbook_protection: None,
373            book_views: None,
374            sheets: Sheets {
375                sheets: vec![SheetEntry {
376                    name: "Sheet1".to_string(),
377                    sheet_id: 1,
378                    state: None,
379                    r_id: "rId1".to_string(),
380                }],
381            },
382            external_references: None,
383            defined_names: None,
384            calc_pr: None,
385            ole_size: None,
386            pivot_caches: None,
387        }
388    }
389}
390
391#[cfg(test)]
392mod tests {
393    use super::*;
394
395    #[test]
396    fn test_workbook_passthrough_elements_roundtrip_in_schema_order() {
397        let xml = r#"<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><fileSharing readOnlyRecommended="true" userName="owner" reservationPassword="ABCD"/><workbookPr dateCompatibility="true" refreshAllConnections="true"/><sheets><sheet name="Sheet1" sheetId="1" r:id="rId1"/></sheets><externalReferences><externalReference r:id="rId2"/><externalReference r:id="rId3"/></externalReferences><definedNames/><calcPr calcId="1"/><oleSize ref="A1:C3"/><pivotCaches/></workbook>"#;
398
399        let workbook: WorkbookXml = quick_xml::de::from_str(xml).unwrap();
400        assert_eq!(
401            workbook.file_sharing.as_ref().unwrap().user_name.as_deref(),
402            Some("owner")
403        );
404        assert_eq!(
405            workbook
406                .external_references
407                .as_ref()
408                .unwrap()
409                .references
410                .len(),
411            2
412        );
413        assert_eq!(workbook.ole_size.as_ref().unwrap().reference, "A1:C3");
414        assert_eq!(
415            workbook.workbook_pr.as_ref().unwrap().date_compatibility,
416            Some(true)
417        );
418        assert_eq!(
419            workbook
420                .workbook_pr
421                .as_ref()
422                .unwrap()
423                .refresh_all_connections,
424            Some(true)
425        );
426
427        let serialized = quick_xml::se::to_string(&workbook).unwrap();
428        assert!(serialized.find("fileSharing").unwrap() < serialized.find("workbookPr").unwrap());
429        assert!(
430            serialized.find("externalReferences").unwrap()
431                < serialized.find("definedNames").unwrap()
432        );
433        assert!(serialized.find("calcPr").unwrap() < serialized.find("oleSize").unwrap());
434        let reparsed: WorkbookXml = quick_xml::de::from_str(&serialized).unwrap();
435        assert_eq!(workbook, reparsed);
436    }
437
438    #[test]
439    fn test_workbook_default() {
440        let wb = WorkbookXml::default();
441        assert_eq!(wb.xmlns, namespaces::SPREADSHEET_ML);
442        assert_eq!(wb.xmlns_r, namespaces::RELATIONSHIPS);
443        assert_eq!(wb.sheets.sheets.len(), 1);
444        assert_eq!(wb.sheets.sheets[0].name, "Sheet1");
445        assert_eq!(wb.sheets.sheets[0].sheet_id, 1);
446        assert_eq!(wb.sheets.sheets[0].r_id, "rId1");
447        assert!(wb.sheets.sheets[0].state.is_none());
448        assert!(wb.file_version.is_none());
449        assert!(wb.workbook_pr.is_none());
450        assert!(wb.workbook_protection.is_none());
451        assert!(wb.book_views.is_none());
452        assert!(wb.defined_names.is_none());
453        assert!(wb.calc_pr.is_none());
454        assert!(wb.pivot_caches.is_none());
455    }
456
457    #[test]
458    fn test_workbook_roundtrip() {
459        let wb = WorkbookXml::default();
460        let xml = quick_xml::se::to_string(&wb).unwrap();
461        let parsed: WorkbookXml = quick_xml::de::from_str(&xml).unwrap();
462        assert_eq!(wb.xmlns, parsed.xmlns);
463        assert_eq!(wb.xmlns_r, parsed.xmlns_r);
464        assert_eq!(wb.sheets.sheets.len(), parsed.sheets.sheets.len());
465        assert_eq!(wb.sheets.sheets[0].name, parsed.sheets.sheets[0].name);
466        assert_eq!(
467            wb.sheets.sheets[0].sheet_id,
468            parsed.sheets.sheets[0].sheet_id
469        );
470        assert_eq!(wb.sheets.sheets[0].r_id, parsed.sheets.sheets[0].r_id);
471    }
472
473    #[test]
474    fn test_workbook_serialize_structure() {
475        let wb = WorkbookXml::default();
476        let xml = quick_xml::se::to_string(&wb).unwrap();
477        assert!(xml.contains("<workbook"));
478        assert!(xml.contains("<sheets>"));
479        assert!(xml.contains("<sheet "));
480        assert!(xml.contains("name=\"Sheet1\""));
481        assert!(xml.contains("sheetId=\"1\""));
482    }
483
484    #[test]
485    fn test_workbook_optional_fields_not_serialized() {
486        let wb = WorkbookXml::default();
487        let xml = quick_xml::se::to_string(&wb).unwrap();
488        assert!(!xml.contains("fileVersion"));
489        assert!(!xml.contains("workbookPr"));
490        assert!(!xml.contains("workbookProtection"));
491        assert!(!xml.contains("bookViews"));
492        assert!(!xml.contains("definedNames"));
493        assert!(!xml.contains("calcPr"));
494        assert!(!xml.contains("pivotCaches"));
495    }
496
497    #[test]
498    fn test_workbook_with_all_optional_fields() {
499        let wb = WorkbookXml {
500            xmlns: namespaces::SPREADSHEET_ML.to_string(),
501            xmlns_r: namespaces::RELATIONSHIPS.to_string(),
502            file_version: Some(FileVersion {
503                app_name: Some("xl".to_string()),
504                last_edited: Some("7".to_string()),
505                lowest_edited: Some("7".to_string()),
506                rup_build: Some("27425".to_string()),
507            }),
508            file_sharing: None,
509            workbook_pr: Some(WorkbookPr {
510                date1904: Some(false),
511                date_compatibility: None,
512                filter_privacy: None,
513                default_theme_version: Some(166925),
514                show_objects: None,
515                backup_file: None,
516                code_name: None,
517                check_compatibility: None,
518                auto_compress_pictures: None,
519                refresh_all_connections: None,
520                save_external_link_values: None,
521                update_links: None,
522                hide_pivot_field_list: None,
523                show_pivot_chart_filter: None,
524                allow_refresh_query: None,
525                publish_items: None,
526                show_border_unselected_tables: None,
527                prompted_solutions: None,
528                show_ink_annotation: None,
529            }),
530            workbook_protection: None,
531            book_views: Some(BookViews {
532                workbook_views: vec![WorkbookView {
533                    x_window: Some(0),
534                    y_window: Some(0),
535                    window_width: Some(28800),
536                    window_height: Some(12210),
537                    active_tab: Some(0),
538                }],
539            }),
540            sheets: Sheets {
541                sheets: vec![SheetEntry {
542                    name: "Sheet1".to_string(),
543                    sheet_id: 1,
544                    state: None,
545                    r_id: "rId1".to_string(),
546                }],
547            },
548            external_references: None,
549            defined_names: None,
550            calc_pr: Some(CalcPr {
551                calc_id: Some(191029),
552                calc_mode: None,
553                full_calc_on_load: None,
554                ref_mode: None,
555                iterate: None,
556                iterate_count: None,
557                iterate_delta: None,
558                full_precision: None,
559                calc_completed: None,
560                calc_on_save: None,
561                concurrent_calc: None,
562                concurrent_manual_count: None,
563                force_full_calc: None,
564            }),
565            ole_size: None,
566            pivot_caches: None,
567        };
568
569        let xml = quick_xml::se::to_string(&wb).unwrap();
570        let parsed: WorkbookXml = quick_xml::de::from_str(&xml).unwrap();
571        assert!(parsed.file_version.is_some());
572        assert!(parsed.workbook_pr.is_some());
573        assert!(parsed.book_views.is_some());
574        assert!(parsed.calc_pr.is_some());
575        assert_eq!(
576            parsed.file_version.as_ref().unwrap().app_name,
577            Some("xl".to_string())
578        );
579        assert_eq!(parsed.calc_pr.as_ref().unwrap().calc_id, Some(191029));
580    }
581
582    #[test]
583    fn test_parse_real_excel_workbook() {
584        let xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
585<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
586  <sheets>
587    <sheet name="Sheet1" sheetId="1" r:id="rId1"/>
588    <sheet name="Sheet2" sheetId="2" r:id="rId2"/>
589  </sheets>
590</workbook>"#;
591
592        let parsed: WorkbookXml = quick_xml::de::from_str(xml).unwrap();
593        assert_eq!(parsed.sheets.sheets.len(), 2);
594        assert_eq!(parsed.sheets.sheets[0].name, "Sheet1");
595        assert_eq!(parsed.sheets.sheets[0].r_id, "rId1");
596        assert_eq!(parsed.sheets.sheets[1].name, "Sheet2");
597        assert_eq!(parsed.sheets.sheets[1].r_id, "rId2");
598    }
599
600    #[test]
601    fn test_multiple_sheets() {
602        let wb = WorkbookXml {
603            sheets: Sheets {
604                sheets: vec![
605                    SheetEntry {
606                        name: "Data".to_string(),
607                        sheet_id: 1,
608                        state: None,
609                        r_id: "rId1".to_string(),
610                    },
611                    SheetEntry {
612                        name: "Summary".to_string(),
613                        sheet_id: 2,
614                        state: None,
615                        r_id: "rId2".to_string(),
616                    },
617                    SheetEntry {
618                        name: "Hidden".to_string(),
619                        sheet_id: 3,
620                        state: Some("hidden".to_string()),
621                        r_id: "rId3".to_string(),
622                    },
623                ],
624            },
625            ..WorkbookXml::default()
626        };
627
628        let xml = quick_xml::se::to_string(&wb).unwrap();
629        let parsed: WorkbookXml = quick_xml::de::from_str(&xml).unwrap();
630        assert_eq!(parsed.sheets.sheets.len(), 3);
631        assert_eq!(parsed.sheets.sheets[2].state, Some("hidden".to_string()));
632    }
633
634    #[test]
635    fn test_sheet_entry_state_not_serialized_when_none() {
636        let entry = SheetEntry {
637            name: "Sheet1".to_string(),
638            sheet_id: 1,
639            state: None,
640            r_id: "rId1".to_string(),
641        };
642        let xml = quick_xml::se::to_string(&entry).unwrap();
643        assert!(!xml.contains("state"));
644    }
645
646    #[test]
647    fn test_extended_workbook_pr_roundtrip() {
648        let pr = WorkbookPr {
649            date1904: Some(false),
650            date_compatibility: Some(true),
651            filter_privacy: Some(true),
652            default_theme_version: Some(166925),
653            show_objects: Some("all".to_string()),
654            backup_file: Some(true),
655            code_name: Some("ThisWorkbook".to_string()),
656            check_compatibility: Some(true),
657            auto_compress_pictures: Some(false),
658            refresh_all_connections: Some(true),
659            save_external_link_values: Some(true),
660            update_links: Some("always".to_string()),
661            hide_pivot_field_list: Some(false),
662            show_pivot_chart_filter: Some(true),
663            allow_refresh_query: Some(true),
664            publish_items: Some(false),
665            show_border_unselected_tables: Some(true),
666            prompted_solutions: Some(false),
667            show_ink_annotation: Some(true),
668        };
669        let xml = quick_xml::se::to_string(&pr).unwrap();
670        let parsed: WorkbookPr = quick_xml::de::from_str(&xml).unwrap();
671        assert_eq!(pr, parsed);
672        assert!(xml.contains("showObjects=\"all\""));
673        assert!(xml.contains("backupFile=\"true\""));
674        assert!(xml.contains("codeName=\"ThisWorkbook\""));
675        assert!(xml.contains("checkCompatibility=\"true\""));
676        assert!(xml.contains("autoCompressPictures=\"false\""));
677        assert!(xml.contains("saveExternalLinkValues=\"true\""));
678        assert!(xml.contains("updateLinks=\"always\""));
679        assert!(xml.contains("hidePivotFieldList=\"false\""));
680        assert!(xml.contains("showPivotChartFilter=\"true\""));
681        assert!(xml.contains("allowRefreshQuery=\"true\""));
682        assert!(xml.contains("publishItems=\"false\""));
683        assert!(xml.contains("showBorderUnselectedTables=\"true\""));
684        assert!(xml.contains("promptedSolutions=\"false\""));
685        assert!(xml.contains("showInkAnnotation=\"true\""));
686    }
687
688    #[test]
689    fn test_extended_calc_pr_roundtrip() {
690        let calc = CalcPr {
691            calc_id: Some(191029),
692            calc_mode: Some("auto".to_string()),
693            full_calc_on_load: Some(true),
694            ref_mode: Some("A1".to_string()),
695            iterate: Some(true),
696            iterate_count: Some(100),
697            iterate_delta: Some(0.001),
698            full_precision: Some(true),
699            calc_completed: Some(true),
700            calc_on_save: Some(true),
701            concurrent_calc: Some(true),
702            concurrent_manual_count: Some(4),
703            force_full_calc: Some(false),
704        };
705        let xml = quick_xml::se::to_string(&calc).unwrap();
706        let parsed: CalcPr = quick_xml::de::from_str(&xml).unwrap();
707        assert_eq!(calc, parsed);
708        assert!(xml.contains("refMode=\"A1\""));
709        assert!(xml.contains("iterate=\"true\""));
710        assert!(xml.contains("iterateCount=\"100\""));
711        assert!(xml.contains("iterateDelta=\"0.001\""));
712        assert!(xml.contains("fullPrecision=\"true\""));
713        assert!(xml.contains("calcCompleted=\"true\""));
714        assert!(xml.contains("calcOnSave=\"true\""));
715        assert!(xml.contains("concurrentCalc=\"true\""));
716        assert!(xml.contains("concurrentManualCount=\"4\""));
717        assert!(xml.contains("forceFullCalc=\"false\""));
718    }
719
720    #[test]
721    fn test_workbook_protection_roundtrip() {
722        let prot = WorkbookProtection {
723            workbook_password: Some("ABCD".to_string()),
724            lock_structure: Some(true),
725            lock_windows: Some(false),
726            revisions_password: Some("1234".to_string()),
727            lock_revision: Some(true),
728        };
729        let xml = quick_xml::se::to_string(&prot).unwrap();
730        let parsed: WorkbookProtection = quick_xml::de::from_str(&xml).unwrap();
731        assert_eq!(prot, parsed);
732        assert!(xml.contains("workbookPassword=\"ABCD\""));
733        assert!(xml.contains("lockStructure=\"true\""));
734        assert!(xml.contains("lockWindows=\"false\""));
735        assert!(xml.contains("revisionsPassword=\"1234\""));
736        assert!(xml.contains("lockRevision=\"true\""));
737    }
738
739    #[test]
740    fn test_workbook_protection_optional_fields_skipped() {
741        let prot = WorkbookProtection {
742            workbook_password: None,
743            lock_structure: Some(true),
744            lock_windows: None,
745            revisions_password: None,
746            lock_revision: None,
747        };
748        let xml = quick_xml::se::to_string(&prot).unwrap();
749        assert!(!xml.contains("workbookPassword"));
750        assert!(xml.contains("lockStructure=\"true\""));
751        assert!(!xml.contains("lockWindows"));
752        assert!(!xml.contains("revisionsPassword"));
753        assert!(!xml.contains("lockRevision"));
754    }
755
756    #[test]
757    fn test_workbook_xml_with_protection_roundtrip() {
758        let wb = WorkbookXml {
759            workbook_protection: Some(WorkbookProtection {
760                workbook_password: Some("CC23".to_string()),
761                lock_structure: Some(true),
762                lock_windows: None,
763                revisions_password: None,
764                lock_revision: None,
765            }),
766            ..WorkbookXml::default()
767        };
768        let xml = quick_xml::se::to_string(&wb).unwrap();
769        let parsed: WorkbookXml = quick_xml::de::from_str(&xml).unwrap();
770        assert!(parsed.workbook_protection.is_some());
771        let prot = parsed.workbook_protection.unwrap();
772        assert_eq!(prot.workbook_password, Some("CC23".to_string()));
773        assert_eq!(prot.lock_structure, Some(true));
774    }
775
776    #[test]
777    fn test_workbook_xml_element_order() {
778        let wb = WorkbookXml {
779            workbook_pr: Some(WorkbookPr {
780                date1904: Some(false),
781                date_compatibility: None,
782                filter_privacy: None,
783                default_theme_version: None,
784                show_objects: None,
785                backup_file: None,
786                code_name: None,
787                check_compatibility: None,
788                auto_compress_pictures: None,
789                refresh_all_connections: None,
790                save_external_link_values: None,
791                update_links: None,
792                hide_pivot_field_list: None,
793                show_pivot_chart_filter: None,
794                allow_refresh_query: None,
795                publish_items: None,
796                show_border_unselected_tables: None,
797                prompted_solutions: None,
798                show_ink_annotation: None,
799            }),
800            workbook_protection: Some(WorkbookProtection {
801                workbook_password: None,
802                lock_structure: Some(true),
803                lock_windows: None,
804                revisions_password: None,
805                lock_revision: None,
806            }),
807            book_views: Some(BookViews {
808                workbook_views: vec![WorkbookView {
809                    x_window: Some(0),
810                    y_window: Some(0),
811                    window_width: Some(28800),
812                    window_height: Some(12210),
813                    active_tab: None,
814                }],
815            }),
816            ..WorkbookXml::default()
817        };
818        let xml = quick_xml::se::to_string(&wb).unwrap();
819        let pr_pos = xml
820            .find("workbookPr")
821            .expect("workbookPr should be present");
822        let prot_pos = xml
823            .find("workbookProtection")
824            .expect("workbookProtection should be present");
825        let bv_pos = xml.find("bookViews").expect("bookViews should be present");
826        assert!(
827            pr_pos < prot_pos,
828            "workbookPr ({pr_pos}) should come before workbookProtection ({prot_pos})"
829        );
830        assert!(
831            prot_pos < bv_pos,
832            "workbookProtection ({prot_pos}) should come before bookViews ({bv_pos})"
833        );
834    }
835}