barehttp 0.0.1

A minimal, explicit HTTP client for Rust with no_std support and blocking I/O
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
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346

/// RFC 9112 Phase 1 and Phase 2 Compliance Tests
/// Tests for critical request building and response parsing fixes
use crate::parser::*;
extern crate alloc;
use alloc::string::String;

// ============================================================================
// Phase 1.1: Empty Path Handling (RFC 9112 Section 3.2.1)
// ============================================================================

#[test]
fn test_empty_path_sends_slash() {
  // RFC 9112 Section 3.2.1: If origin-form path is empty, send "/"
  let request = RequestBuilder::new("GET", "")
    .header("Host", "example.com")
    .build()
    .unwrap();
  let request_str = String::from_utf8_lossy(&request);

  assert!(
    request_str.starts_with("GET / HTTP/1.1\r\n"),
    "Empty path should be converted to '/'. Got: {request_str}"
  );
}

#[test]
fn test_non_empty_path_preserved() {
  // Verify non-empty paths are not modified
  let request = RequestBuilder::new("GET", "/api/users")
    .header("Host", "example.com")
    .build()
    .unwrap();
  let request_str = String::from_utf8_lossy(&request);

  assert!(
    request_str.starts_with("GET /api/users HTTP/1.1\r\n"),
    "Non-empty path should be preserved. Got: {request_str}"
  );
}

#[test]
fn test_path_with_query_preserved() {
  // Verify paths with query strings work correctly
  let request = RequestBuilder::new("GET", "/search?q=test")
    .header("Host", "example.com")
    .build()
    .unwrap();
  let request_str = String::from_utf8_lossy(&request);

  assert!(
    request_str.starts_with("GET /search?q=test HTTP/1.1\r\n"),
    "Path with query should be preserved. Got: {request_str}"
  );
}

// ============================================================================
// Phase 1.3: No Extra CRLF (RFC 9112 Section 2.2)
// ============================================================================

#[test]
fn test_no_leading_crlf_in_request() {
  // RFC 9112 Section 2.2: HTTP/1.1 user agent MUST NOT preface request with extra CRLF
  let request = RequestBuilder::new("GET", "/")
    .header("Host", "example.com")
    .build()
    .unwrap();

  // Should start directly with method, not with CRLF
  assert!(request.starts_with(b"GET"), "Request should not have leading CRLF");
  assert!(!request.starts_with(b"\r\n"), "Request should not start with CRLF");
}

#[test]
fn test_no_trailing_crlf_after_body() {
  // RFC 9112 Section 2.2: MUST NOT follow request with extra CRLF
  let body = b"test body".to_vec();
  let request = RequestBuilder::new("POST", "/")
    .header("Host", "example.com")
    .body(body)
    .build()
    .unwrap();

  // Should end with body content, not extra CRLF
  assert!(
    request.ends_with(b"test body"),
    "Request should not have trailing CRLF after body"
  );
  assert!(
    !request.ends_with(b"test body\r\n"),
    "Request should not end with CRLF after body"
  );
}

#[test]
fn test_exactly_one_blank_line_before_body() {
  // Verify exactly one blank line (CRLF CRLF) separates headers from body
  let body = b"content".to_vec();
  let request = RequestBuilder::new("POST", "/")
    .header("Host", "example.com")
    .header("Content-Type", "text/plain")
    .body(body)
    .build()
    .unwrap();

  let request_str = String::from_utf8_lossy(&request);

  // Should have exactly one blank line before body
  assert!(
    request_str.contains("\r\n\r\ncontent"),
    "Should have exactly one blank line before body"
  );
  assert!(
    !request_str.contains("\r\n\r\n\r\n"),
    "Should not have multiple blank lines"
  );
}

#[test]
fn test_exactly_one_crlf_after_each_header() {
  // Verify each header ends with exactly one CRLF
  let request = RequestBuilder::new("GET", "/")
    .header("Host", "example.com")
    .header("User-Agent", "test")
    .build()
    .unwrap();

  let request_str = String::from_utf8_lossy(&request);

  // Should not have double CRLF after headers (except the blank line)
  let header_section = request_str.split("\r\n\r\n").next().unwrap();
  assert!(
    !header_section.contains("\r\n\r\n"),
    "Headers should not have double CRLF within them"
  );
}

// ============================================================================
// Phase 2.1: Conflicting TE+CL Handling (RFC 9112 Section 6.3)
// ============================================================================

#[test]
fn test_te_and_cl_conflict_rejected() {
  // RFC 9112 Section 6.3: If both TE and CL present, client MUST reject
  let input = b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\nContent-Length: 5\r\n\r\n5\r\nHello\r\n0\r\n\r\n";
  let result = Response::parse(input);

  assert!(result.is_err(), "Response with both TE and CL should be rejected");
  if let Err(e) = result {
    assert!(
      matches!(e, crate::error::ParseError::ConflictingFraming),
      "Should return ConflictingFraming error, got: {e:?}"
    );
  }
}

#[test]
fn test_te_without_cl_accepted() {
  // Transfer-Encoding without Content-Length should work
  let input = b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nHello\r\n0\r\n\r\n";
  let result = Response::parse(input);

  assert!(result.is_ok(), "Response with only TE should be accepted");
  let response = result.unwrap();
  assert_eq!(response.body.as_bytes(), b"Hello");
}

#[test]
fn test_cl_without_te_accepted() {
  // Content-Length without Transfer-Encoding should work
  let input = b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nHello";
  let result = Response::parse(input);

  assert!(result.is_ok(), "Response with only CL should be accepted");
  let response = result.unwrap();
  assert_eq!(response.body.as_bytes(), b"Hello");
}

// ============================================================================
// Phase 2.2: 2xx CONNECT Special Case (RFC 9112 Section 6.3)
// ============================================================================

#[test]
fn test_connect_2xx_ignores_content_length() {
  // RFC 9112 Section 6.3: 2xx to CONNECT ignores Content-Length
  let input = b"HTTP/1.1 200 OK\r\nContent-Length: 100\r\n\r\nThis should be ignored";

  // Parse with CONNECT method
  let (status_line, after_status) = crate::parser::http::StatusLine::parse(&input[..]).unwrap();
  let (headers_bytes, remaining) = crate::parser::headers::HeaderField::parse(after_status).unwrap();

  let body_bytes = Response::parse_body(remaining, &headers_bytes, status_line.status.code(), Some("CONNECT")).unwrap();

  assert!(
    body_bytes.is_empty(),
    "2xx CONNECT response should ignore Content-Length and have no body"
  );
}

#[test]
fn test_connect_non_2xx_processes_body_normally() {
  // Non-2xx CONNECT responses should process body normally
  let input = b"HTTP/1.1 400 Bad Request\r\nContent-Length: 5\r\n\r\nError";

  let (status_line, after_status) = crate::parser::http::StatusLine::parse(&input[..]).unwrap();
  let (headers_bytes, remaining) = crate::parser::headers::HeaderField::parse(after_status).unwrap();

  let body_bytes = Response::parse_body(remaining, &headers_bytes, status_line.status.code(), Some("CONNECT")).unwrap();

  assert_eq!(
    body_bytes, b"Error",
    "Non-2xx CONNECT response should process body normally"
  );
}

#[test]
fn test_connect_2xx_ignores_transfer_encoding() {
  // RFC 9112 Section 6.3: 2xx to CONNECT ignores Transfer-Encoding
  let input = b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nHello\r\n0\r\n\r\n";

  let (status_line, after_status) = crate::parser::http::StatusLine::parse(&input[..]).unwrap();
  let (headers_bytes, remaining) = crate::parser::headers::HeaderField::parse(after_status).unwrap();

  let body_bytes = Response::parse_body(remaining, &headers_bytes, status_line.status.code(), Some("CONNECT")).unwrap();

  assert!(
    body_bytes.is_empty(),
    "2xx CONNECT response should ignore Transfer-Encoding and have no body"
  );
}

// ============================================================================
// Phase 2.4: Invalid Content-Length Handling (RFC 9112 Section 6.3)
// ============================================================================

#[test]
fn test_invalid_content_length_rejected() {
  // RFC 9112 Section 6.3: Invalid Content-Length is unrecoverable error
  let input = b"HTTP/1.1 200 OK\r\nContent-Length: invalid\r\n\r\n";
  let result = Response::parse(input);

  // Should parse successfully but treat as no Content-Length
  assert!(result.is_ok(), "Should handle invalid Content-Length gracefully");
  let response = result.unwrap();
  assert!(
    response.body.is_empty(),
    "Invalid Content-Length should result in no body"
  );
}

#[test]
fn test_multiple_identical_content_length_accepted() {
  // RFC 9112 allows comma-separated identical values
  let input = b"HTTP/1.1 200 OK\r\nContent-Length: 5, 5, 5\r\n\r\nHello";
  let result = Response::parse(input);

  assert!(
    result.is_ok(),
    "Multiple identical Content-Length values should be accepted"
  );
  let response = result.unwrap();
  assert_eq!(response.body.as_bytes(), b"Hello");
}

#[test]
fn test_multiple_different_content_length_rejected() {
  // Different Content-Length values should be rejected
  let input = b"HTTP/1.1 200 OK\r\nContent-Length: 5, 10\r\n\r\nHello";
  let result = Response::parse(input);

  // Should parse but treat as invalid Content-Length
  assert!(result.is_ok(), "Should handle conflicting Content-Length gracefully");
  let response = result.unwrap();
  assert!(
    response.body.is_empty(),
    "Conflicting Content-Length should result in no body"
  );
}

#[test]
fn test_content_length_with_non_digits_rejected() {
  // Content-Length with non-digit characters should be rejected
  let input = b"HTTP/1.1 200 OK\r\nContent-Length: 5abc\r\n\r\n";
  let result = Response::parse(input);

  assert!(result.is_ok(), "Should handle malformed Content-Length gracefully");
  let response = result.unwrap();
  assert!(
    response.body.is_empty(),
    "Malformed Content-Length should result in no body"
  );
}

#[test]
fn test_content_length_with_whitespace_accepted() {
  // Content-Length with leading/trailing whitespace should be accepted
  let input = b"HTTP/1.1 200 OK\r\nContent-Length:  5  \r\n\r\nHello";
  let result = Response::parse(input);

  assert!(result.is_ok(), "Content-Length with whitespace should be accepted");
  let response = result.unwrap();
  assert_eq!(response.body.as_bytes(), b"Hello");
}

// ============================================================================
// Integration Tests
// ============================================================================

#[test]
fn test_complete_request_with_all_phase1_fixes() {
  // Test a complete request with all Phase 1 fixes applied
  let request = RequestBuilder::new("POST", "")
    .header("Host", "example.com")
    .header("Content-Type", "application/json")
    .body(b"{\"test\":true}".to_vec())
    .build()
    .unwrap();

  let request_str = String::from_utf8_lossy(&request);

  // Should start with method (no leading CRLF)
  assert!(
    request_str.starts_with("POST / HTTP/1.1\r\n"),
    "Should have correct start line with / for empty path"
  );

  // Should have Host header
  assert!(request_str.contains("Host: example.com\r\n"), "Should have Host header");

  // Should end with body (no trailing CRLF)
  assert!(
    request_str.ends_with("{\"test\":true}"),
    "Should end with body content without trailing CRLF"
  );
}

#[test]
fn test_complete_response_with_all_phase2_fixes() {
  // Test a complete response parsing with all Phase 2 fixes
  let input = b"HTTP/1.1 200 OK\r\nContent-Length: 13\r\n\r\nHello, World!";
  let result = Response::parse(input);

  assert!(result.is_ok(), "Valid response should parse successfully");
  let response = result.unwrap();
  assert_eq!(response.status_code, 200);
  assert_eq!(response.body.as_bytes(), b"Hello, World!");
}