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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

//! POP3 protocol edge case tests.

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

use tokio::io::BufReader;

use liburlx::protocol::pop3::{read_multiline, read_response, send_command};

// --- Response reading ---

#[tokio::test]
async fn read_ok_response() {
    let data = b"+OK POP3 server ready\r\n";
    let mut reader = BufReader::new(std::io::Cursor::new(data.to_vec()));
    let resp = read_response(&mut reader).await.unwrap();
    assert!(resp.ok);
    assert!(resp.message.contains("POP3 server ready"));
}

#[tokio::test]
async fn read_err_response() {
    let data = b"-ERR authentication failed\r\n";
    let mut reader = BufReader::new(std::io::Cursor::new(data.to_vec()));
    let resp = read_response(&mut reader).await.unwrap();
    assert!(!resp.ok);
    assert!(resp.message.contains("authentication failed"));
}

#[tokio::test]
async fn read_ok_with_stats() {
    let data = b"+OK 3 messages (1234 octets)\r\n";
    let mut reader = BufReader::new(std::io::Cursor::new(data.to_vec()));
    let resp = read_response(&mut reader).await.unwrap();
    assert!(resp.ok);
    assert!(resp.message.contains("3 messages"));
}

#[tokio::test]
async fn read_empty_ok() {
    let data = b"+OK\r\n";
    let mut reader = BufReader::new(std::io::Cursor::new(data.to_vec()));
    let resp = read_response(&mut reader).await.unwrap();
    assert!(resp.ok);
}

#[tokio::test]
async fn read_empty_stream_error() {
    let data = b"";
    let mut reader = BufReader::new(std::io::Cursor::new(data.to_vec()));
    let result = read_response(&mut reader).await;
    assert!(result.is_err());
}

#[tokio::test]
async fn read_sequential_responses() {
    let data = b"+OK Ready\r\n+OK User accepted\r\n";
    let mut reader = BufReader::new(std::io::Cursor::new(data.to_vec()));
    let r1 = read_response(&mut reader).await.unwrap();
    assert!(r1.ok);
    let r2 = read_response(&mut reader).await.unwrap();
    assert!(r2.ok);
}

// --- Multiline reading ---

#[tokio::test]
async fn multiline_basic_list() {
    let data = b"+OK 3 messages\r\n1 120\r\n2 250\r\n3 340\r\n.\r\n";
    let mut reader = BufReader::new(std::io::Cursor::new(data.to_vec()));
    // Read the initial response line
    let _resp = read_response(&mut reader).await.unwrap();
    // Read the multiline data
    let lines = read_multiline(&mut reader).await.unwrap();
    assert_eq!(lines.len(), 3);
    assert!(lines[0].contains("1 120"));
    assert!(lines[2].contains("3 340"));
}

#[tokio::test]
async fn multiline_empty() {
    let data = b".\r\n";
    let mut reader = BufReader::new(std::io::Cursor::new(data.to_vec()));
    let lines = read_multiline(&mut reader).await.unwrap();
    assert!(lines.is_empty());
}

#[tokio::test]
async fn multiline_with_dot_stuffing() {
    let data = b"Hello\r\n..This had a dot\r\n.\r\n";
    let mut reader = BufReader::new(std::io::Cursor::new(data.to_vec()));
    let lines = read_multiline(&mut reader).await.unwrap();
    assert_eq!(lines.len(), 2);
    assert_eq!(lines[0], "Hello");
    assert_eq!(lines[1], ".This had a dot");
}

#[tokio::test]
async fn multiline_single_line() {
    let data = b"Just one line\r\n.\r\n";
    let mut reader = BufReader::new(std::io::Cursor::new(data.to_vec()));
    let lines = read_multiline(&mut reader).await.unwrap();
    assert_eq!(lines.len(), 1);
    assert_eq!(lines[0], "Just one line");
}

// --- send_command ---

#[tokio::test]
async fn send_user_command() {
    let mut buf = Vec::new();
    send_command(&mut buf, "USER testuser").await.unwrap();
    assert_eq!(buf, b"USER testuser\r\n");
}

#[tokio::test]
async fn send_pass_command() {
    let mut buf = Vec::new();
    send_command(&mut buf, "PASS secret123").await.unwrap();
    assert_eq!(buf, b"PASS secret123\r\n");
}

#[tokio::test]
async fn send_list_command() {
    let mut buf = Vec::new();
    send_command(&mut buf, "LIST").await.unwrap();
    assert_eq!(buf, b"LIST\r\n");
}

#[tokio::test]
async fn send_retr_command() {
    let mut buf = Vec::new();
    send_command(&mut buf, "RETR 1").await.unwrap();
    assert_eq!(buf, b"RETR 1\r\n");
}

#[tokio::test]
async fn send_quit_command() {
    let mut buf = Vec::new();
    send_command(&mut buf, "QUIT").await.unwrap();
    assert_eq!(buf, b"QUIT\r\n");
}

// --- Pop3Response struct ---

#[test]
fn pop3_response_ok_field() {
    let resp = liburlx::protocol::pop3::Pop3Response { ok: true, message: "success".to_string() };
    assert!(resp.ok);
    assert_eq!(resp.message, "success");
}

#[test]
fn pop3_response_err_field() {
    let resp = liburlx::protocol::pop3::Pop3Response { ok: false, message: "failed".to_string() };
    assert!(!resp.ok);
}