Debian Codegraph @

third_party/rust/neqo-http3/tests/priority.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 use std::time::Instant;
8
9 use neqo_common::event::Provider as _;
10 use neqo_crypto::AuthenticationStatus;
11 use neqo_http3::{
12 Header, Http3Client, Http3ClientEvent, Http3Server, Http3ServerEvent, Http3State, Priority,
13 };
14 use test_fixture::*;
15
16 fn exchange_packets(client: &mut Http3Client, server: &mut Http3Server) {
17 let mut out = None;
18 loop {
19 out = client.process(out, now()).dgram();
20 let client_done = out.is_none();
21 out = server.process(out, now()).dgram();
22 if out.is_none() && client_done {
23 break;
24 }
25 }
26 }
27
28 // Perform only QUIC transport handshake.
29 fn connect_with(client: &mut Http3Client, server: &mut Http3Server) {
30 assert_eq!(client.state(), Http3State::Initializing);
31 let out = client.process_output(now());
32 let out2 = client.process_output(now());
33 assert_eq!(client.state(), Http3State::Initializing);
34
35 _ = server.process(out.dgram(), now());
36 let out = server.process(out2.dgram(), now());
37 let out = client.process(out.dgram(), now());
38 let out = server.process(out.dgram(), now());
39 let out = client.process(out.dgram(), now());
40 let out = server.process(out.dgram(), now());
41 assert!(out.as_dgram_ref().is_none());
42
43 let authentication_needed = |e| matches!(e, Http3ClientEvent::AuthenticationNeeded);
44 assert!(client.events().any(authentication_needed));
45 client.authenticated(AuthenticationStatus::Ok, now());
46
47 let out = client.process(out.dgram(), now());
48 let connected = |e| matches!(e, Http3ClientEvent::StateChange(Http3State::Connected));
49 assert!(client.events().any(connected));
50
51 assert_eq!(client.state(), Http3State::Connected);
52 // Exchange H3 settings
53 let out = server.process(out.dgram(), now());
54 let out = client.process(out.dgram(), now());
55 let out = server.process(out.dgram(), now());
56 let out = client.process(out.dgram(), now());
57 _ = server.process(out.dgram(), now());
58 }
59
60 fn connect() -> (Http3Client, Http3Server) {
61 let mut client = default_http3_client();
62 let mut server = default_http3_server();
63 connect_with(&mut client, &mut server);
64 (client, server)
65 }
66
67 #[test]
68 fn priority_update() {
69 let (mut client, mut server) = connect();
70 let stream_id = client
71 .fetch(
72 Instant::now(),
73 "GET",
74 &("https", "something.com", "/"),
75 &[Header::new("priority", "u=4,i")],
76 Priority::new(4, true),
77 )
78 .unwrap();
79 exchange_packets(&mut client, &mut server);
80
81 // get event of the above request, skipping events of the connection setup
82 let header_event = loop {
83 let event = server.next_event().unwrap();
84 if matches!(event, Http3ServerEvent::Headers { .. }) {
85 break event;
86 }
87 };
88
89 match header_event {
90 Http3ServerEvent::Headers { headers, fin, .. } => {
91 let expected_headers = &[
92 Header::new(":method", "GET"),
93 Header::new(":scheme", "https"),
94 Header::new(":authority", "something.com"),
95 Header::new(":path", "/"),
96 Header::new("priority", "u=4,i"),
97 ];
98 assert_eq!(&headers, expected_headers);
99 assert!(!fin);
100 }
101 other => panic!("unexpected server event: {other:?}"),
102 }
103
104 let update_priority = Priority::new(3, false);
105 client.priority_update(stream_id, update_priority).unwrap();
106 exchange_packets(&mut client, &mut server);
107
108 let found = server.events().any(|e| {
109 if let Http3ServerEvent::PriorityUpdate {
110 stream_id: update_id,
111 priority,
112 } = e
113 {
114 assert_eq!(update_id, stream_id);
115 assert_eq!(priority, update_priority);
116 true
117 } else {
118 false
119 }
120 });
121 assert!(found);
122 }
123
124 #[test]
125 fn priority_update_dont_send_for_cancelled_stream() {
126 let (mut client, mut server) = connect();
127 let stream_id = client
128 .fetch(
129 Instant::now(),
130 "GET",
131 &("https", "something.com", "/"),
132 &[Header::new("priority", "u=5")],
133 Priority::new(5, false),
134 )
135 .unwrap();
136 exchange_packets(&mut client, &mut server);
137
138 let update_priority = Priority::new(6, false);
139 client.priority_update(stream_id, update_priority).unwrap();
140 client.cancel_fetch(stream_id, 11).unwrap();
141 exchange_packets(&mut client, &mut server);
142
143 while let Some(event) = server.next_event() {
144 if matches!(event, Http3ServerEvent::PriorityUpdate { .. }) {
145 panic!("Priority update sent on cancelled stream");
146 }
147 }
148 }