liburlx 0.2.2

A memory-safe URL transfer library β€” idiomatic Rust reimplementation of libcurl
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

//! File protocol edge case tests.
//!
//! Tests file:// URL handling for various filesystem scenarios.

#![allow(clippy::unwrap_used, clippy::expect_used, unused_results)]

// --- File with special characters in name ---

#[tokio::test]
async fn file_with_spaces_in_name() {
    let dir = tempfile::tempdir().unwrap();
    let file_path = dir.path().join("test file.txt");
    std::fs::write(&file_path, "space content").unwrap();

    let mut easy = liburlx::Easy::new();
    // Percent-encode the space
    let url = format!("file://{}", file_path.display().to_string().replace(' ', "%20"));
    easy.url(&url).unwrap();
    let resp = easy.perform_async().await.unwrap();

    assert_eq!(resp.status(), 200);
    assert_eq!(resp.body_str().unwrap(), "space content");
}

// --- Large file ---

#[tokio::test]
async fn file_large_content() {
    let dir = tempfile::tempdir().unwrap();
    let file_path = dir.path().join("large.bin");
    let data = vec![0x42u8; 100_000];
    std::fs::write(&file_path, &data).unwrap();

    let mut easy = liburlx::Easy::new();
    easy.url(&format!("file://{}", file_path.display())).unwrap();
    let resp = easy.perform_async().await.unwrap();

    assert_eq!(resp.status(), 200);
    assert_eq!(resp.body().len(), 100_000);
}

// --- File with unicode content ---

#[tokio::test]
async fn file_unicode_content() {
    let dir = tempfile::tempdir().unwrap();
    let file_path = dir.path().join("unicode.txt");
    std::fs::write(&file_path, "Hello δΈ–η•Œ 🌍").unwrap();

    let mut easy = liburlx::Easy::new();
    easy.url(&format!("file://{}", file_path.display())).unwrap();
    let resp = easy.perform_async().await.unwrap();

    assert_eq!(resp.status(), 200);
    assert_eq!(resp.body_str().unwrap(), "Hello δΈ–η•Œ 🌍");
}

// --- File effective URL ---

#[tokio::test]
async fn file_effective_url_preserved() {
    let dir = tempfile::tempdir().unwrap();
    let file_path = dir.path().join("test.txt");
    std::fs::write(&file_path, "content").unwrap();

    let url = format!("file://{}", file_path.display());
    let mut easy = liburlx::Easy::new();
    easy.url(&url).unwrap();
    let resp = easy.perform_async().await.unwrap();

    // The effective URL should contain the file path (URL-normalized)
    assert!(resp.effective_url().starts_with("file://"));
    assert!(resp.effective_url().contains("test.txt"));
}

// --- File size_download ---

#[tokio::test]
async fn file_size_download_matches() {
    let dir = tempfile::tempdir().unwrap();
    let file_path = dir.path().join("sized.txt");
    std::fs::write(&file_path, "12345").unwrap();

    let mut easy = liburlx::Easy::new();
    easy.url(&format!("file://{}", file_path.display())).unwrap();
    let resp = easy.perform_async().await.unwrap();

    assert_eq!(resp.size_download(), 5);
}

// --- Non-existent file ---

#[tokio::test]
async fn file_nonexistent_returns_error() {
    let mut easy = liburlx::Easy::new();
    easy.url("file:///tmp/urlx_definitely_not_exists_12345.txt").unwrap();
    let result = easy.perform_async().await;
    assert!(result.is_err());
}

// --- Empty file ---

#[tokio::test]
async fn file_empty_content() {
    let dir = tempfile::tempdir().unwrap();
    let file_path = dir.path().join("empty.txt");
    std::fs::File::create(&file_path).unwrap();

    let mut easy = liburlx::Easy::new();
    easy.url(&format!("file://{}", file_path.display())).unwrap();
    let resp = easy.perform_async().await.unwrap();

    assert_eq!(resp.status(), 200);
    assert!(resp.body().is_empty());
}

// --- File with nested path ---

#[tokio::test]
async fn file_nested_directory() {
    let dir = tempfile::tempdir().unwrap();
    let nested = dir.path().join("a").join("b").join("c");
    std::fs::create_dir_all(&nested).unwrap();
    let file_path = nested.join("deep.txt");
    std::fs::write(&file_path, "deep content").unwrap();

    let mut easy = liburlx::Easy::new();
    easy.url(&format!("file://{}", file_path.display())).unwrap();
    let resp = easy.perform_async().await.unwrap();

    assert_eq!(resp.body_str().unwrap(), "deep content");
}