Debian Codegraph @

third_party/rust/neqo-http3/tests/send_message.rs

raw
1 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
2 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
4 // option. This file may not be copied, modified, or distributed
5 // except according to those terms.
6
7 #![cfg(test)]
8
9 use std::sync::OnceLock;
10
11 use neqo_common::event::Provider as _;
12 use neqo_crypto::AuthenticationStatus;
13 use neqo_http3::{
14 Error, Header, Http3Client, Http3ClientEvent, Http3OrWebTransportStream, Http3Server,
15 Http3ServerEvent, Priority,
16 };
17 use test_fixture::*;
18
19 const RESPONSE_DATA: &[u8] = &[0x61, 0x62, 0x63];
20
21 fn response_header_no_data() -> &'static Vec<Header> {
22 static HEADERS: OnceLock<Vec<Header>> = OnceLock::new();
23 HEADERS.get_or_init(|| vec![Header::new(":status", "200"), Header::new("something", "3")])
24 }
25
26 fn response_header_103() -> &'static Vec<Header> {
27 static HEADERS: OnceLock<Vec<Header>> = OnceLock::new();
28 HEADERS.get_or_init(|| vec![Header::new(":status", "103"), Header::new("link", "...")])
29 }
30
31 fn exchange_packets(client: &mut Http3Client, server: &mut Http3Server) {
32 let mut out = None;
33 loop {
34 out = client.process(out, now()).dgram();
35 out = server.process(out, now()).dgram();
36 if out.is_none() {
37 break;
38 }
39 }
40 }
41
42 fn receive_request(server: &Http3Server) -> Option<Http3OrWebTransportStream> {
43 while let Some(event) = server.next_event() {
44 if let Http3ServerEvent::Headers {
45 stream,
46 headers,
47 fin,
48 } = event
49 {
50 assert_eq!(
51 &headers,
52 &[
53 Header::new(":method", "GET"),
54 Header::new(":scheme", "https"),
55 Header::new(":authority", "something.com"),
56 Header::new(":path", "/")
57 ]
58 );
59 assert!(fin);
60 return Some(stream);
61 }
62 }
63 None
64 }
65
66 fn send_trailers(request: &Http3OrWebTransportStream) -> Result<(), Error> {
67 request.send_headers(&[
68 Header::new("something1", "something"),
69 Header::new("something2", "3"),
70 ])
71 }
72
73 fn send_informational_headers(request: &Http3OrWebTransportStream) -> Result<(), Error> {
74 request.send_headers(response_header_103())
75 }
76
77 fn send_headers(request: &Http3OrWebTransportStream) -> Result<(), Error> {
78 request.send_headers(&[
79 Header::new(":status", "200"),
80 Header::new("content-length", "3"),
81 ])
82 }
83
84 fn process_client_events(conn: &mut Http3Client) {
85 let mut response_header_found = false;
86 let mut response_data_found = false;
87 while let Some(event) = conn.next_event() {
88 match event {
89 Http3ClientEvent::HeaderReady { headers, fin, .. } => {
90 assert!(
91 (headers.as_ref()
92 == [
93 Header::new(":status", "200"),
94 Header::new("content-length", "3"),
95 ])
96 || (headers.as_ref() == *response_header_103())
97 );
98 assert!(!fin);
99 response_header_found = true;
100 }
101 Http3ClientEvent::DataReadable { stream_id } => {
102 let mut buf = [0u8; 100];
103 let (amount, fin) = conn.read_data(now(), stream_id, &mut buf).unwrap();
104 assert!(fin);
105 assert_eq!(amount, RESPONSE_DATA.len());
106 assert_eq!(&buf[..RESPONSE_DATA.len()], RESPONSE_DATA);
107 response_data_found = true;
108 }
109 _ => {}
110 }
111 }
112 assert!(response_header_found);
113 assert!(response_data_found);
114 }
115
116 fn process_client_events_no_data(conn: &mut Http3Client) {
117 let mut response_header_found = false;
118 let mut fin_received = false;
119 while let Some(event) = conn.next_event() {
120 match event {
121 Http3ClientEvent::HeaderReady { headers, fin, .. } => {
122 assert_eq!(headers.as_ref(), *response_header_no_data());
123 fin_received = fin;
124 response_header_found = true;
125 }
126 Http3ClientEvent::DataReadable { stream_id } => {
127 let mut buf = [0u8; 100];
128 let (amount, fin) = conn.read_data(now(), stream_id, &mut buf).unwrap();
129 assert!(fin);
130 fin_received = true;
131 assert_eq!(amount, 0);
132 }
133 _ => {}
134 }
135 }
136 assert!(response_header_found);
137 assert!(fin_received);
138 }
139
140 fn connect_send_and_receive_request() -> (Http3Client, Http3Server, Http3OrWebTransportStream) {
141 let mut hconn_c = default_http3_client();
142 let mut hconn_s = default_http3_server();
143
144 exchange_packets(&mut hconn_c, &mut hconn_s);
145 let authentication_needed = |e| matches!(e, Http3ClientEvent::AuthenticationNeeded);
146 assert!(hconn_c.events().any(authentication_needed));
147 hconn_c.authenticated(AuthenticationStatus::Ok, now());
148 exchange_packets(&mut hconn_c, &mut hconn_s);
149
150 let req = hconn_c
151 .fetch(
152 now(),
153 "GET",
154 &("https", "something.com", "/"),
155 &[],
156 Priority::default(),
157 )
158 .unwrap();
159 assert_eq!(req, 0);
160 hconn_c.stream_close_send(req).unwrap();
161 exchange_packets(&mut hconn_c, &mut hconn_s);
162
163 let request = receive_request(&hconn_s).unwrap();
164
165 (hconn_c, hconn_s, request)
166 }
167
168 #[test]
169 fn response_trailers1() {
170 let (mut hconn_c, mut hconn_s, request) = connect_send_and_receive_request();
171 send_headers(&request).unwrap();
172 request.send_data(RESPONSE_DATA).unwrap();
173 send_trailers(&request).unwrap();
174 request.stream_close_send().unwrap();
175 exchange_packets(&mut hconn_c, &mut hconn_s);
176 process_client_events(&mut hconn_c);
177 }
178
179 #[test]
180 fn response_trailers2() {
181 let (mut hconn_c, mut hconn_s, request) = connect_send_and_receive_request();
182 send_headers(&request).unwrap();
183 request.send_data(RESPONSE_DATA).unwrap();
184 exchange_packets(&mut hconn_c, &mut hconn_s);
185 send_trailers(&request).unwrap();
186 request.stream_close_send().unwrap();
187 exchange_packets(&mut hconn_c, &mut hconn_s);
188 process_client_events(&mut hconn_c);
189 }
190
191 #[test]
192 fn response_trailers3() {
193 let (mut hconn_c, mut hconn_s, request) = connect_send_and_receive_request();
194 send_headers(&request).unwrap();
195 request.send_data(RESPONSE_DATA).unwrap();
196 exchange_packets(&mut hconn_c, &mut hconn_s);
197 send_trailers(&request).unwrap();
198 exchange_packets(&mut hconn_c, &mut hconn_s);
199 request.stream_close_send().unwrap();
200 exchange_packets(&mut hconn_c, &mut hconn_s);
201 process_client_events(&mut hconn_c);
202 }
203
204 #[test]
205 fn response_trailers_no_data() {
206 let (mut hconn_c, mut hconn_s, request) = connect_send_and_receive_request();
207 request.send_headers(response_header_no_data()).unwrap();
208 exchange_packets(&mut hconn_c, &mut hconn_s);
209 send_trailers(&request).unwrap();
210 exchange_packets(&mut hconn_c, &mut hconn_s);
211 request.stream_close_send().unwrap();
212 exchange_packets(&mut hconn_c, &mut hconn_s);
213 process_client_events_no_data(&mut hconn_c);
214 }
215
216 #[test]
217 fn multiple_response_trailers() {
218 let (mut hconn_c, mut hconn_s, request) = connect_send_and_receive_request();
219 send_headers(&request).unwrap();
220 request.send_data(RESPONSE_DATA).unwrap();
221 exchange_packets(&mut hconn_c, &mut hconn_s);
222 send_trailers(&request).unwrap();
223 exchange_packets(&mut hconn_c, &mut hconn_s);
224
225 assert_eq!(send_trailers(&request), Err(Error::InvalidInput));
226
227 request.stream_close_send().unwrap();
228 exchange_packets(&mut hconn_c, &mut hconn_s);
229 process_client_events(&mut hconn_c);
230 }
231
232 #[test]
233 fn data_after_trailer() {
234 let (mut hconn_c, mut hconn_s, request) = connect_send_and_receive_request();
235 send_headers(&request).unwrap();
236 request.send_data(RESPONSE_DATA).unwrap();
237 exchange_packets(&mut hconn_c, &mut hconn_s);
238 send_trailers(&request).unwrap();
239 exchange_packets(&mut hconn_c, &mut hconn_s);
240
241 assert_eq!(request.send_data(RESPONSE_DATA), Err(Error::InvalidInput));
242
243 request.stream_close_send().unwrap();
244 exchange_packets(&mut hconn_c, &mut hconn_s);
245 process_client_events(&mut hconn_c);
246 }
247
248 #[test]
249 fn trailers_after_close() {
250 let (mut hconn_c, mut hconn_s, request) = connect_send_and_receive_request();
251 send_headers(&request).unwrap();
252 request.send_data(RESPONSE_DATA).unwrap();
253 request.stream_close_send().unwrap();
254
255 assert_eq!(send_trailers(&request), Err(Error::InvalidStreamId));
256
257 exchange_packets(&mut hconn_c, &mut hconn_s);
258 process_client_events(&mut hconn_c);
259 }
260
261 #[test]
262 fn multiple_response_headers() {
263 let (mut hconn_c, mut hconn_s, request) = connect_send_and_receive_request();
264 request.send_headers(response_header_no_data()).unwrap();
265
266 assert_eq!(
267 request.send_headers(response_header_no_data()),
268 Err(Error::InvalidHeader)
269 );
270
271 request.stream_close_send().unwrap();
272 exchange_packets(&mut hconn_c, &mut hconn_s);
273 process_client_events_no_data(&mut hconn_c);
274 }
275
276 #[test]
277 fn informational_after_response_headers() {
278 let (mut hconn_c, mut hconn_s, request) = connect_send_and_receive_request();
279 request.send_headers(response_header_no_data()).unwrap();
280
281 assert_eq!(
282 send_informational_headers(&request),
283 Err(Error::InvalidHeader)
284 );
285
286 request.stream_close_send().unwrap();
287 exchange_packets(&mut hconn_c, &mut hconn_s);
288 process_client_events_no_data(&mut hconn_c);
289 }
290
291 #[test]
292 fn data_after_informational() {
293 let (mut hconn_c, mut hconn_s, request) = connect_send_and_receive_request();
294 send_informational_headers(&request).unwrap();
295
296 assert_eq!(request.send_data(RESPONSE_DATA), Err(Error::InvalidInput));
297
298 send_headers(&request).unwrap();
299 request.send_data(RESPONSE_DATA).unwrap();
300 request.stream_close_send().unwrap();
301 exchange_packets(&mut hconn_c, &mut hconn_s);
302 process_client_events(&mut hconn_c);
303 }
304
305 #[test]
306 fn non_trailers_headers_after_data() {
307 let (mut hconn_c, mut hconn_s, request) = connect_send_and_receive_request();
308 send_headers(&request).unwrap();
309 request.send_data(RESPONSE_DATA).unwrap();
310 exchange_packets(&mut hconn_c, &mut hconn_s);
311
312 assert_eq!(
313 request.send_headers(response_header_no_data()),
314 Err(Error::InvalidHeader)
315 );
316
317 request.stream_close_send().unwrap();
318 exchange_packets(&mut hconn_c, &mut hconn_s);
319 process_client_events(&mut hconn_c);
320 }
321
322 #[test]
323 fn data_before_headers() {
324 let (mut hconn_c, mut hconn_s, request) = connect_send_and_receive_request();
325 assert_eq!(request.send_data(RESPONSE_DATA), Err(Error::InvalidInput));
326
327 send_headers(&request).unwrap();
328 request.send_data(RESPONSE_DATA).unwrap();
329 request.stream_close_send().unwrap();
330 exchange_packets(&mut hconn_c, &mut hconn_s);
331 process_client_events(&mut hconn_c);
332 }