office2pdf 0.5.0

Convert DOCX, XLSX, and PPTX files to PDF using pure Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use std::io::Cursor;

use super::*;

fn build_xlsx_with_rows(num_rows: u32, num_cols: u32) -> Vec<u8> {
    let mut book = umya_spreadsheet::new_file();
    let sheet = book.get_sheet_mut(&0).unwrap();
    sheet.set_name("Data");
    for row in 1..=num_rows {
        for col in 1..=num_cols {
            sheet
                .get_cell_mut((col, row))
                .set_value(format!("R{row}C{col}"));
        }
    }
    let mut cursor = Cursor::new(Vec::new());
    umya_spreadsheet::writer::xlsx::write_writer(&book, &mut cursor).unwrap();
    cursor.into_inner()
}

#[test]
fn test_streaming_xlsx_produces_valid_pdf() {
    let data = build_xlsx_with_rows(50, 3);
    let options = config::ConvertOptions {
        streaming: true,
        streaming_chunk_size: Some(20),
        ..Default::default()
    };
    let result = convert_bytes(&data, config::Format::Xlsx, &options).unwrap();
    assert!(
        result.pdf.starts_with(b"%PDF"),
        "output should be valid PDF"
    );
    assert!(result.pdf.len() > 100, "PDF should have content");
}

#[test]
fn test_streaming_xlsx_same_data_as_normal() {
    let data = build_xlsx_with_rows(10, 2);

    let normal_opts = config::ConvertOptions::default();
    let normal_result = convert_bytes(&data, config::Format::Xlsx, &normal_opts).unwrap();

    let streaming_opts = config::ConvertOptions {
        streaming: true,
        streaming_chunk_size: Some(5),
        ..Default::default()
    };
    let streaming_result = convert_bytes(&data, config::Format::Xlsx, &streaming_opts).unwrap();

    assert!(normal_result.pdf.starts_with(b"%PDF"));
    assert!(streaming_result.pdf.starts_with(b"%PDF"));
    assert!(normal_result.pdf.len() > 100);
    assert!(streaming_result.pdf.len() > 100);
}

#[test]
fn test_streaming_large_xlsx_completes() {
    let data = build_xlsx_with_rows(10_000, 3);
    let options = config::ConvertOptions {
        streaming: true,
        streaming_chunk_size: Some(1000),
        ..Default::default()
    };
    let result = convert_bytes(&data, config::Format::Xlsx, &options).unwrap();
    assert!(
        result.pdf.starts_with(b"%PDF"),
        "output should be valid PDF"
    );
    assert!(result.metrics.is_some(), "streaming should produce metrics");
}

#[test]
fn test_streaming_non_xlsx_falls_through() {
    let docx = {
        let doc = docx_rs::Docx::new().add_paragraph(
            docx_rs::Paragraph::new().add_run(docx_rs::Run::new().add_text("Hello streaming")),
        );
        let mut cursor = Cursor::new(Vec::new());
        doc.build().pack(&mut cursor).unwrap();
        cursor.into_inner()
    };
    let options = config::ConvertOptions {
        streaming: true,
        ..Default::default()
    };
    let result = convert_bytes(&docx, config::Format::Docx, &options).unwrap();
    assert!(result.pdf.starts_with(b"%PDF"));
}

#[test]
fn test_streaming_chunk_size_default() {
    let data = build_xlsx_with_rows(20, 1);
    let options = config::ConvertOptions {
        streaming: true,
        streaming_chunk_size: None,
        ..Default::default()
    };
    let result = convert_bytes(&data, config::Format::Xlsx, &options).unwrap();
    assert!(result.pdf.starts_with(b"%PDF"));
}

#[test]
fn test_streaming_memory_bounded() {
    let data = build_xlsx_with_rows(5_000, 5);
    let options = config::ConvertOptions {
        streaming: true,
        streaming_chunk_size: Some(500),
        ..Default::default()
    };
    let result = convert_bytes(&data, config::Format::Xlsx, &options).unwrap();
    assert!(result.pdf.starts_with(b"%PDF"));
    assert!(
        result.pdf.len() > 1000,
        "PDF should have substantial content"
    );
}