html_view 0.2.2

A Rust library for rendering HTML content in a native tauri application.
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316

//! Integration tests for the full viewer lifecycle
//!
//! These tests require the html_view_app binary to be built.
//! They will be skipped if the binary is not available.

use html_view::{ViewerOptions, ViewerWaitMode};
use html_view_shared::ViewerContent;

#[test]
#[ignore] // Run with: cargo test --ignored
fn test_viewer_inline_html_blocking() {
    // This test requires the html_view_app binary
    let html = r#"
        <!DOCTYPE html>
        <html>
        <head><title>Test</title></head>
        <body><h1>Integration Test</h1></body>
        </html>
    "#;

    let mut options = ViewerOptions::inline_html(html);
    options.environment.timeout_seconds = Some(1); // Auto-close after 1 second
    options.window.width = Some(400);
    options.window.height = Some(300);

    // This should complete successfully after ~1 second
    let result = html_view::open(options);

    match result {
        Ok(_) => println!("Viewer lifecycle test passed"),
        Err(e) => {
            if e.to_string().contains("binary not found") {
                println!("Skipping test: html_view_app not available");
                println!("Run 'cargo build' in html_view_app directory first");
            } else {
                panic!("Viewer lifecycle test failed: {}", e);
            }
        }
    }
}

#[test]
#[ignore]
fn test_viewer_non_blocking() {
    let html = "<h1>Non-blocking Test</h1>";

    let mut options = ViewerOptions::inline_html(html);
    options.wait = ViewerWaitMode::NonBlocking;
    options.environment.timeout_seconds = Some(2);
    options.window.width = Some(300);
    options.window.height = Some(200);

    let result = html_view::open(options);

    match result {
        Ok(viewer_result) => {
            if let html_view::ViewerResult::NonBlocking(handle) = viewer_result {
                println!("Got handle, waiting for completion...");
                match handle.wait() {
                    Ok(status) => {
                        println!("Viewer exited: {:?}", status.reason);
                    }
                    Err(e) => {
                        panic!("Wait failed: {}", e);
                    }
                }
            } else {
                panic!("Expected NonBlocking result");
            }
        }
        Err(e) => {
            if e.to_string().contains("binary not found") {
                println!("Skipping test: html_view_app not available");
            } else {
                panic!("Non-blocking test failed: {}", e);
            }
        }
    }
}

#[test]
#[ignore]
fn test_viewer_try_wait() {
    use std::thread;
    use std::time::Duration;

    let html = "<h1>Try Wait Test</h1>";

    let mut options = ViewerOptions::inline_html(html);
    options.wait = ViewerWaitMode::NonBlocking;
    options.environment.timeout_seconds = Some(3);

    let result = html_view::open(options);

    match result {
        Ok(viewer_result) => {
            if let html_view::ViewerResult::NonBlocking(mut handle) = viewer_result {
                // Poll for completion
                let mut attempts = 0;
                loop {
                    attempts += 1;
                    match handle.try_wait() {
                        Ok(Some(status)) => {
                            println!(
                                "Viewer completed after {} attempts: {:?}",
                                attempts, status.reason
                            );
                            break;
                        }
                        Ok(None) => {
                            println!("Attempt {}: Still running...", attempts);
                            thread::sleep(Duration::from_millis(500));
                        }
                        Err(e) => {
                            panic!("try_wait failed: {}", e);
                        }
                    }

                    if attempts > 10 {
                        panic!("try_wait took too long");
                    }
                }
            } else {
                panic!("Expected NonBlocking result");
            }
        }
        Err(e) => {
            if e.to_string().contains("binary not found") {
                println!("Skipping test: html_view_app not available");
            } else {
                panic!("Try wait test failed: {}", e);
            }
        }
    }
}

#[test]
#[ignore]
fn test_viewer_terminate() {
    use std::thread;
    use std::time::Duration;

    let html = "<h1>Terminate Test</h1>";

    let mut options = ViewerOptions::inline_html(html);
    options.wait = ViewerWaitMode::NonBlocking;
    // No timeout - we'll terminate it manually
    options.window.width = Some(300);
    options.window.height = Some(200);

    let result = html_view::open(options);

    match result {
        Ok(viewer_result) => {
            if let html_view::ViewerResult::NonBlocking(mut handle) = viewer_result {
                // Give it time to start
                thread::sleep(Duration::from_millis(500));

                // Terminate it
                match handle.terminate() {
                    Ok(_) => println!("Viewer terminated successfully"),
                    Err(e) => panic!("Terminate failed: {}", e),
                }

                // Verify it's no longer running
                match handle.try_wait() {
                    Ok(Some(_)) => println!("Viewer confirmed terminated"),
                    Ok(None) => panic!("Viewer still running after terminate"),
                    Err(e) => {
                        // On some platforms, trying to wait after kill might error
                        println!("try_wait after terminate: {}", e);
                    }
                }
            } else {
                panic!("Expected NonBlocking result");
            }
        }
        Err(e) => {
            if e.to_string().contains("binary not found") {
                println!("Skipping test: html_view_app not available");
            } else {
                panic!("Terminate test failed: {}", e);
            }
        }
    }
}

#[test]
#[ignore]
fn test_viewer_with_devtools() {
    let html = "<h1>DevTools Test</h1><script>console.log('DevTools enabled');</script>";

    let mut options = ViewerOptions::inline_html(html);
    options.behaviour.enable_devtools = true;
    options.environment.timeout_seconds = Some(2);

    let result = html_view::open(options);

    match result {
        Ok(_) => println!("DevTools test completed"),
        Err(e) => {
            if e.to_string().contains("binary not found") {
                println!("Skipping test: html_view_app not available");
            } else {
                panic!("DevTools test failed: {}", e);
            }
        }
    }
}

#[test]
#[ignore]
fn test_viewer_window_options() {
    let html = "<h1>Window Options Test</h1>";

    let mut options = ViewerOptions::inline_html(html);
    options.window.width = Some(800);
    options.window.height = Some(600);
    options.window.resizable = true;
    options.window.title = Some("Integration Test Window".to_string());
    options.environment.timeout_seconds = Some(1);

    let result = html_view::open(options);

    match result {
        Ok(_) => println!("Window options test completed"),
        Err(e) => {
            if e.to_string().contains("binary not found") {
                println!("Skipping test: html_view_app not available");
            } else {
                panic!("Window options test failed: {}", e);
            }
        }
    }
}

#[test]
#[ignore]
fn test_viewer_version_check() {
    // This test verifies that version checking works correctly
    let html = "<h1>Version Check Test</h1>";

    let mut options = ViewerOptions::inline_html(html);
    options.environment.timeout_seconds = Some(1);

    let result = html_view::open(options);

    match result {
        Ok(_) => {
            println!("Version check passed - versions are compatible");
        }
        Err(e) => {
            if e.to_string().contains("version mismatch") {
                println!(
                    "Version mismatch detected (expected if library and viewer versions differ)"
                );
                println!("Error: {}", e);
            } else if e.to_string().contains("binary not found") {
                println!("Skipping test: html_view_app not available");
            } else {
                panic!("Version check test failed: {}", e);
            }
        }
    }
}

#[test]
fn test_viewer_content_variants() {
    // Test that all ViewerContent variants can be constructed
    use std::path::PathBuf;
    use url::Url;

    let inline = ViewerContent::InlineHtml {
        html: "<h1>Test</h1>".to_string(),
        base_dir: None,
    };
    assert!(matches!(inline, ViewerContent::InlineHtml { .. }));

    let file = ViewerContent::LocalFile {
        path: PathBuf::from("/tmp/test.html"),
    };
    assert!(matches!(file, ViewerContent::LocalFile { .. }));

    let app_dir = ViewerContent::AppDir {
        root: PathBuf::from("/tmp/app"),
        entry: Some("index.html".to_string()),
    };
    assert!(matches!(app_dir, ViewerContent::AppDir { .. }));

    let url = ViewerContent::RemoteUrl {
        url: Url::parse("https://example.com").unwrap(),
    };
    assert!(matches!(url, ViewerContent::RemoteUrl { .. }));
}

#[test]
fn test_viewer_options_builder_pattern() {
    // Test that ViewerOptions can be constructed and modified
    let mut options = ViewerOptions::inline_html("<h1>Test</h1>");

    // Modify various options
    options.window.width = Some(1024);
    options.window.height = Some(768);
    options.window.title = Some("Test Window".to_string());
    options.behaviour.enable_devtools = true;
    options.environment.timeout_seconds = Some(30);
    options.wait = ViewerWaitMode::NonBlocking;

    // Verify the modifications
    assert_eq!(options.window.width, Some(1024));
    assert_eq!(options.window.height, Some(768));
    assert_eq!(options.window.title, Some("Test Window".to_string()));
    assert!(options.behaviour.enable_devtools);
    assert_eq!(options.environment.timeout_seconds, Some(30));
    assert!(matches!(options.wait, ViewerWaitMode::NonBlocking));
}