| 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 |
} |